OOPS Assignment-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6f2e38c0-5d3a-43a4-8968-682b7cb2d312",
   "metadata": {},
   "source": [
    "OOPS Assignment -2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32fcf418-272d-4728-84c0-a0e6477fb02f",
   "metadata": {},
   "source": [
    "#### Constructor : "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "243239d2-bdb2-4156-80e9-8e00575f6572",
   "metadata": {},
   "source": [
    "1. What is a constructor in Python? Explain its purpose and usage"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84ea97d9-ffd5-4431-b55b-c53768a53907",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Constructor is used to creating and initializing object of instance of class. by using thise constructor we can pass argument as input to function. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b52976c0-5926-426d-b9d4-fa2fc6848ae5",
   "metadata": {},
   "source": [
    "2. Differentiate between a parameterless constructor and a parameterized constructor in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc0d9a73-108e-4652-a0c3-856a033e7224",
   "metadata": {},
   "source": [
    "Ans: \n",
    "    \n",
    "    Parameterized constructor : the parameterized constructor that can take place one or more argument.it is used to create object with custom values.\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6641f6d-eb5e-451f-b983-e6dd977a4d26",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    parameterless constructor : the parameterless constructor that cannot take place any aruguments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4112f3bd-f872-4a2f-a7a0-94a74a34ff65",
   "metadata": {},
   "source": [
    "3. How do you define a constructor in a Python class? Provide an example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "038013d9-71e6-4939-a4a3-ce596412dd7f",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    We can define constructor in python by using __init__ method. thise method is also called as dunder method. We have given example of constructor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7bdbf0ec-fb8d-4a1b-a847-2273691e2d76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26\n",
      "bhush\n"
     ]
    }
   ],
   "source": [
    "class person :\n",
    "    \n",
    "    def __init__(self ,name ,age):\n",
    "        self.name =name \n",
    "        self.age =age\n",
    "        \n",
    "obj_person =person(\"bhush\",26)\n",
    "print(obj_person.age)\n",
    "print(obj_person.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "886de6c9-a00c-4601-95a1-b292c8024d6e",
   "metadata": {},
   "source": [
    "4. Explain the `__init__` method in Python and its role in constructors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d744873c-3186-49c2-86c6-a5e399994a09",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    __init__ is a constructor in python which accept which accept number of arguments.it is used to creating and initializing object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c8833e7-e1aa-4df2-b5f3-bd33e873dcfd",
   "metadata": {},
   "source": [
    "5. In a class named `Person`, create a constructor that initializes the `name` and `age` attributes. Provide an example of creating an object of this class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5bfce6a2-c8dc-409b-8256-680134dcf7ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "class person :\n",
    "    \n",
    "    def __init__(self ,name ,age ):\n",
    "        self.name =name \n",
    "        self.age =age "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "55769b9c-7a65-4057-b23c-2ab50795c0ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_person =person(\"Bhushan\" ,27)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "37b51f78-74ca-4926-a654-60d3a4f04293",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_person.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d110e254-4615-468e-a72e-46e3c4d019d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bhushan'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_person.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7568a328-af5c-4de7-ad47-0f5e4b81a502",
   "metadata": {},
   "source": [
    "6. How can you call a constructor explicitly in Python? Give an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79e50a5e-e2ac-415f-9dfb-b2be826cbe5a",
   "metadata": {},
   "source": [
    "Ans  :\n",
    "    \n",
    "    We can call constructor by using super function. here we provide example -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "941465b0-fa22-4ded-b86a-f66a7a4b55a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class parent :\n",
    "    \n",
    "    def __init__(self ,x):\n",
    "        self.x =x\n",
    "        \n",
    "class child(parent):\n",
    "    \n",
    "    def __init__(self ,x):\n",
    "        super().__init__(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3b5a319c-ba98-4026-bb30-73bc5eaf4f9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "pw_obj =child(\"male\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c036f2a1-5eaa-4e6a-9791-49cc81bdffd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'male'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw_obj.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6611522b-3ac7-4ad0-a872-3b4ce7c51b38",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'male'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw_obj.x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a365bc5c-7077-45fc-9603-1d300b5fb7f8",
   "metadata": {},
   "source": [
    "7. What is the significance of the `self` parameter in Python constructors? Explain with an example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b300a305-328d-4288-b0ad-93234a4d18d0",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    self parameter is used to access the attribute and method from class or else self is use to give referance to the class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b84a0ea9-53d7-4a2a-9f41-746195a67b4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class vehicle :\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.age = 26\n",
    "        self.gender =\"male\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "43e4ec6d-39a6-4a93-b16d-d0b2b8ac8281",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_vehicle =vehicle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ceddde4f-72de-461f-bb3d-6ad256fa16ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_vehicle.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a368f714-365b-4a7c-8860-efc4703ed61a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'male'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_vehicle.gender"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5341302-63a1-4ccb-ac0a-077a8acf230f",
   "metadata": {},
   "source": [
    "8. Discuss the concept of default constructors in Python. When are they used?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58016a3c-5996-4956-a4b6-533cf67021f4",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    default constructor :\n",
    "        \n",
    "        default constructor is simple constructor it has not accept any argument.deafault is used when we use to create an object with default values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2245b5e-05c8-401b-b271-1c27809afa69",
   "metadata": {},
   "source": [
    "9. Create a Python class called `Rectangle` with a constructor that initializes the `width` and `height` attributes. Provide a method to calculate the area of the rectangle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "59bd1558-c697-42a7-8201-e7cb74661d6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class rectangle :\n",
    "    \n",
    "    def __init__(self ,width ,height):\n",
    "        self.width =width\n",
    "        self.height =height\n",
    "    \n",
    "    def area_of_rectangle(self):\n",
    "        area =self.width * self.height\n",
    "        return area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9d8a2d72-e3c9-46f4-a93f-beedf4caea39",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_rectangle =rectangle(120 ,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "045081f6-b4b3-4e5b-9492-17f12099d6a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_rectangle.height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "24ce8bf5-6329-4479-b709-dd8c0e047e6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_rectangle.width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dade2ef5-f182-4f58-a01a-40722856da05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18000"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_rectangle.area_of_rectangle()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b90e8ec0-9d99-4c9b-847f-26ef3544a5c7",
   "metadata": {},
   "source": [
    "10. How can you have multiple constructors in a Python class? Explain with an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afe5144b-2da1-43c2-8b25-4ad5264d165e",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    We can use multiple constructor by using @classmethod.thise is a powerful techniques which is allowed to used multiple consdtuctor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "832541f4-3502-4e31-a352-1f7f9519d9ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "class parent :\n",
    "    \n",
    "    def __init__(self ,name ,email):\n",
    "        self.name =name\n",
    "        self.email =email\n",
    "        \n",
    "    @classmethod    \n",
    "    def child(cls ,name,email):\n",
    "        return cls(name ,email)\n",
    "    \n",
    "    def show_details(self):\n",
    "        return self.name ,self.email"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3848b81b-24ac-4917-a5a3-f739e5a0e550",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_child=parent.child(\"Bhushan\",\"bhush@gmail.com\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "fcbca88c-a6a7-4021-9602-2c17fe80af80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bhush@gmail.com'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_child.email"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b4dc4aa0-5caa-456f-aaa7-5d4817199e4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bhushan'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_child.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6faddb40-9b31-4ba1-b1c5-5ffd10fdcd8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Bhushan', 'bhush@gmail.com')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_child.show_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "322c97d1-f24f-4746-acd2-03253c8bb483",
   "metadata": {},
   "source": [
    "11. What is method overloading, and how is it related to constructors in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1257e29a-c9f0-41aa-b4d5-8b7ab6edaea5",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    If two method having same name we call the methods it is overloaded.f the constructor is written two times with different signatures, we call constructor overloading. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48dc01e3-347c-48a9-bfea-82d4474720bd",
   "metadata": {},
   "source": [
    "12. Explain the use of the `super()` function in Python constructors. Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "600dc52c-edcc-47f7-a21a-d002d2834f45",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    suppose if we can define parameter first constructor and same parameter we have define in second constructor the we do not need to define it again by using super function we can use it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b6bcd6d6-fdbc-4570-8e20-4f52f6fb2795",
   "metadata": {},
   "outputs": [],
   "source": [
    "class car :\n",
    "    \n",
    "    def __init__(self, model ,year):\n",
    "        self.model =model\n",
    "        self.year =year\n",
    "        \n",
    "class audi(car):\n",
    "    \n",
    "    def __init__(self, model,year):\n",
    "        super().__init__(model,year)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ea56c5ad-a839-40b3-b72e-4edbc385533a",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_audi1 =audi(\"Audi zx\" ,2022)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "dae848e4-2470-42cd-9916-92485b5b58ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Audi zx'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_audi1.model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "930bdd0c-3ace-49bb-a462-e427069dd26f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2022"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_audi1.year"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73099dc9-9eec-4382-9f92-7b4e510becff",
   "metadata": {},
   "source": [
    "13. Create a class called `Book` with a constructor that initializes the `title`, `author`, and `published_year` attributes. Provide a method to display book details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "478487de-ee07-47bc-9c9e-c2ac858c804f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class book :\n",
    "    \n",
    "    def __init__(self ,title ,author ,publish_year):\n",
    "        self.title =title\n",
    "        self.author =author\n",
    "        self.publish_year =publish_year\n",
    "        \n",
    "    def display_book_details(self):\n",
    "        return self.title ,self.author ,self.publish_year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "15f099e9-aa4f-40df-8914-e25c651b534c",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_book =book(\"Dont Believe everything\",\"josef\",2016)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "07879023-06b6-4536-a27e-8f5934481671",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'josef'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_book.author"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "93ec40cc-5cba-4054-b475-717020004665",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_book.publish_year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "09a43b19-4edd-452f-a7be-33fc20b3fa0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dont Believe everything'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_book.title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "7bbeea71-de28-4d2a-9c9e-51c5b203d79b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Dont Believe everything', 'josef', 2016)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_book.display_book_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec6db494-dafb-43b2-946e-784e5ef8a64e",
   "metadata": {},
   "source": [
    "14. Discuss the differences between constructors and regular methods in Python classes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9205845e-481f-4afd-b710-f8ee3d45de12",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    A constructor is block of code that initialize newly created object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ce8b68c-a32b-4cd0-bd42-733a381660a4",
   "metadata": {},
   "source": [
    "diff :\n",
    "    \n",
    "    the regualar method is collection of statement which return a values its upon exection.|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b63f7f49-49c6-4f20-926b-35dcab7089a5",
   "metadata": {},
   "source": [
    "15. Explain the role of the `self` parameter in instance variable initialization within a constructor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18ec8c8b-011d-4371-aabc-58ae82944c39",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Self is an instance of class we can access the attribute and method from class. OR self parameter is given referance of paramter to class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b7b5668-d00c-4c1a-87cc-e609fa6ff67d",
   "metadata": {},
   "source": [
    "16. How do you prevent a class from having multiple instances by using constructors in Python? Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54232d6b-27c2-4c63-8cee-8ddd1013fd7b",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    To prevent a class from having multiple instances by using constructors in Python, you can use the Singleton pattern. The Singleton pattern is a design pattern that restricts the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "a39448b9-18ac-42f9-ac16-11a20f215ce8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Singleton object at 0x7f63a3535750>\n"
     ]
    }
   ],
   "source": [
    "class Singleton:\n",
    "    _instance = None\n",
    "\n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        if cls._instance is None:\n",
    "            cls._instance = super().__new__(cls)\n",
    "        return cls._instance\n",
    "\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "    @staticmethod\n",
    "    def get_instance():\n",
    "        if Singleton._instance is None:\n",
    "            Singleton._instance = Singleton()\n",
    "        return Singleton._instance\n",
    "\n",
    "\n",
    "# Usage:\n",
    "\n",
    "singleton_instance = Singleton.get_instance()\n",
    "print(singleton_instance)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d63dcb8b-cc4c-4bc2-8579-b76d40d75935",
   "metadata": {},
   "source": [
    "17. Create a Python class called `Student` with a constructor that takes a list of subjects as a parameter and initializes the `subjects` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "7ff0d0b5-047c-4d26-b436-f5cbb90d26c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class student :\n",
    "    \n",
    "    def __init__(self ,list_of_subject):\n",
    "        self.list_of_subject =list(list_of_subject)\n",
    "        \n",
    "    def show_subject(self):\n",
    "        return self.list_of_subject"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "5a244406-6ffb-4062-be7d-b66ba26a4a4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_student =student([\"Big data\",\"data science\",\"full satck data science \",\"cloud\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "667a81c7-b874-4f20-9035-e13dd7c7c1fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Big data', 'data science', 'full satck data science ', 'cloud']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_student.list_of_subject"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "3d4be44f-848e-4d45-af89-7b7f7fb44afa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Big data', 'data science', 'full satck data science ', 'cloud']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_student.show_subject()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee2511d1-4b49-497e-8116-abf80b18bc6f",
   "metadata": {},
   "source": [
    "18. What is the purpose of the `__del__` method in Python classes, and how does it relate to constructors?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85946224-66d1-4692-8afa-627069a50b67",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    In Python, the __del__() method is referred to as a destructor method. It is called after an object's garbage collection occurs, which happens after all references to the item have been destroyed. Student table created. Destructor called, Student table deleted."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5e7f3b6-a6ac-4f7d-ac99-f8ec01dc6e80",
   "metadata": {},
   "source": [
    "19. Explain the use of constructor chaining in Python. Provide a practical example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67953a46-ff8e-4fe0-af87-476b8cb3097c",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    In Python, constructor chaining is convenient when we are dealing with inheritance. When an instance of a child class is initialized, the constructors of all the parent classes are first invoked and then, in the end, the constructor of the child class is invoked"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "8c2d3223-1e6c-4ef1-9cb9-24d40b39e581",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Human :\n",
    "    def __init__(self):\n",
    "        print(\"Hi this is Human Constructor\")\n",
    "\n",
    "    def whoAmI(self):\n",
    "        print(\"I am Human\")\n",
    "\n",
    "\n",
    "class Man(Human):\n",
    "    def __init__(self):\n",
    "        print(\"Hi this is Man Constructor\")\n",
    "\n",
    "    def whoAmI(self):\n",
    "        print(\"I am Man\")\n",
    "\n",
    "\n",
    "class Woman(Man):\n",
    "    def __init__(self):\n",
    "        print(\"Hi this is Woman Constructor\")\n",
    "\n",
    "    def whoAmI(self):\n",
    "        print(\"I am Woman\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "c6d741e6-99c9-4b40-b89b-6e2114794e37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi this is Woman Constructor\n"
     ]
    }
   ],
   "source": [
    "obj_women =Woman()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "0ae8de27-be3b-4e65-948e-e8f25bfdcf65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method Woman.whoAmI of <__main__.Woman object at 0x7f63a34b4e80>>"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_women.whoAmI"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad01f48f-cfa0-411a-8c55-ded3f01142ac",
   "metadata": {},
   "source": [
    "20. Create a Python class called `Car` with a default constructor that initializes the `make` and `model` attributes. Provide a method to display car information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "9d2977a9-57f6-4b5b-b86c-ef5b3b27b516",
   "metadata": {},
   "outputs": [],
   "source": [
    "class car :\n",
    "    \n",
    "    def __init__(self ,make ,model):\n",
    "        self.make = make\n",
    "        self.model =model\n",
    "        \n",
    "    def display_car_info(self):\n",
    "        return self.make ,self.model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "87429349-fbdc-4d67-bc7c-7bb5badb79de",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_car =car(\"Toyota\" ,2023)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "47dabf14-0c86-4788-9569-a0cf40981f52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Toyota'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_car.make"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "96e83a82-9b27-4eae-bee5-fad8ecb5aa41",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2023"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_car.model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "b81ffcab-b26d-4292-882d-ed4b45d89c42",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Toyota', 2023)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_car.display_car_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54302ea3-d6ce-4707-8031-299861e5ae33",
   "metadata": {},
   "source": [
    "### Inheritance "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e703c968-0f0b-4461-b4ba-9a4276febd6d",
   "metadata": {},
   "source": [
    "1. What is inheritance in Python? Explain its significance in object-oriented programming."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebe301bc-4cac-4b91-8c42-89acd19cc644",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Inheritence is a piller of OOPs in python which one class is inherite to another clas with its attributes and methods.The class whose properties and methods are inherited is known as the Parent class. And the class that inherits the properties from the parent class is the Child class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e56ffe9-1a8b-4f44-8d24-a4bc22c12732",
   "metadata": {},
   "source": [
    "2. Differentiate between single inheritance and multiple inheritance in Python. Provide examples for each."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d03f3fa-2e9c-458b-9ebf-6933f9015673",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Single Inheritasnce : \n",
    "        In single inheritance derived class will inherite single base class ."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "319f5971-2850-462a-8dab-1841272c2cb8",
   "metadata": {},
   "source": [
    "Multiple Inheritance :\n",
    "    \n",
    "    the class base class will be inherite to two or more classes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d89d693-e8b8-445d-ac7d-007332164ce7",
   "metadata": {},
   "source": [
    "3. Create a Python class called `Vehicle` with attributes `color` and `speed`. Then, create a child class called `Car` that inherits from `Vehicle` and adds a `brand` attribute. Provide an example of creating a `Car` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5e3cfcf3-5321-4b09-b10b-b86401832b25",
   "metadata": {},
   "outputs": [],
   "source": [
    "class vehicle :\n",
    "    \n",
    "    def __init__(self, color ,speed):\n",
    "        self.color =color\n",
    "        self.speed =speed\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2c76aaf3-fa67-43f2-8002-90e7835bd212",
   "metadata": {},
   "outputs": [],
   "source": [
    "class car(vehicle) :\n",
    "    \n",
    "    def car_brand(self ,brand):\n",
    "        self.brand =brand\n",
    "        print(f\"thise is {self.brand} car\")\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fdb72223-370a-4feb-8aec-e134ecdca5ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_car =car(\"black\",1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f6547c54-3067-4c9e-af25-22d432c94041",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'black'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_car.color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e63abc27-5c7b-40b8-b2c6-b59dc26ae70e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_car.speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "62e5d4b3-9e1c-4d84-924c-b1f1208d2872",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "thise is AUDI car\n"
     ]
    }
   ],
   "source": [
    "obj_car.car_brand(\"AUDI\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55282bea-4727-468a-ac3e-50dc8b0ce7c2",
   "metadata": {},
   "source": [
    "4. Explain the concept of method overriding in inheritance. Provide a practical example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e24a69d-4b04-4427-8a66-c761929707e3",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Method overriding in Python allows you to use functions and methods with the same name or signature. This method cannot be done in the same class. And overriding can only be done when a child class is derived through inheritance. Runtime polymorphism is certainly exemplified through method overloading."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "813e943b-e4ea-48db-a54c-fa2363428365",
   "metadata": {},
   "outputs": [],
   "source": [
    "class parent :\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.value = \"inside parent\"\n",
    "        \n",
    "    def show_method(self):\n",
    "        return self.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1d191907-d212-46e3-9249-ae59a4fde403",
   "metadata": {},
   "outputs": [],
   "source": [
    "class child(parent):\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.value =\"inside child\"\n",
    "        \n",
    "    def show_method(self):\n",
    "        return self.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "cf65127c-674d-4c78-a1f9-f7e041a3ff46",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_child =child()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "581fa30a-5758-4742-a097-a0dbb87a8f17",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'inside child'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_child.show_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6210da7e-d96b-4706-8376-e0f360a621df",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_parent =parent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e376a194-1738-428c-9a55-728d44543565",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'inside parent'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_parent.show_method()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1284abcd-c633-43cf-85b6-acab601abefa",
   "metadata": {},
   "source": [
    "5. How can you access the methods and attributes of a parent class from a child class in Python? Give an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d15d7760-b2bd-43d7-8efa-61bd815da50a",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    first we can create object of child class which will inherite to parent class. after creation of object all method from child and parent class it will be accessable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "92ba42ff-dfff-4c75-9ecd-58bb06dd26c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class room :\n",
    "    \n",
    "    def __init__(self ,total_fan ,total_lights):\n",
    "        self.total_fan =total_fan\n",
    "        self.total_lights =total_lights\n",
    "        \n",
    "    def show_equipments(self):\n",
    "        print(self.total_fan ,self.total_lights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "d9820bab-684c-4d94-95bb-01914d8fd778",
   "metadata": {},
   "outputs": [],
   "source": [
    "class hall(room):\n",
    "    \n",
    "    def hall_details(self):\n",
    "        self.sofa =\"sofa\"\n",
    "        self.bed =\"bed\"\n",
    "        self.chair= \"chair\"\n",
    "        print(self.sofa , self.bed ,self.chair)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "e1b1bdc1-2a4c-4d8b-910b-c2626cf06afd",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_hall =hall(2 ,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "b34de4a7-04c0-4bb3-b83c-87e4d33e3996",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sofa bed chair\n"
     ]
    }
   ],
   "source": [
    "obj_hall.hall_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "85cc7280-cc64-4f44-bee1-a8e194ec6f0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 10\n"
     ]
    }
   ],
   "source": [
    "obj_hall.show_equipments()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "e4047d63-82a2-4a02-8e84-0e1d2b93cafe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'chair'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_hall.chair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "f530aaf7-acc5-4066-b5de-54c82e095982",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_hall.total_fan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "77371d70-59cd-4597-8b64-e93755715bd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_hall.total_lights"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9648c4c-2f29-4571-a298-71f110918486",
   "metadata": {},
   "source": [
    "6. Discuss the use of the `super()` function in Python inheritance. When and why is it used? Provide an example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db20feb7-cfb2-491a-a355-eab669ab4d93",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    In Python, the super() function is used to refer to the parent class or superclass. It allows you to call methods defined in the superclass from the subclass, enabling you to extend and customize the functionality inherited from the parent class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "2ea741c9-0482-4137-aba3-2352ebeb20dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class emp :\n",
    "    \n",
    "    def __init__(self ,emp_id ,name ,add):\n",
    "        self.emp_id =emp_id\n",
    "        self.name = name\n",
    "        self.add = add\n",
    "        \n",
    "    def show_emp_details(self):\n",
    "        return self.emp_id ,self.name ,self.add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "3192c18d-ea3c-4e2e-aa14-f870361c9187",
   "metadata": {},
   "outputs": [],
   "source": [
    "class freelance(emp):\n",
    "    \n",
    "    def __init__(self ,emp_id ,name ,add ,email_id):\n",
    "        super().__init__(emp_id ,name ,add)\n",
    "        self.email_id =email_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "61e158dd-815e-4f9f-9de9-8be63524fd4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_frelance =freelance(10101 ,\"Bhushan\",\"Pune\",\"Bhush@gmail.com\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "40b68d17-5866-4496-b88f-20220ab3e648",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10101, 'Bhushan', 'Pune')"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_frelance.show_emp_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d9a569dd-123f-4a08-95c2-ec60d06ea8d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bhush@gmail.com'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_frelance.email_id"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdb18e26-6d16-4bb3-8ceb-4445040a6725",
   "metadata": {},
   "source": [
    "7. Create a Python class called `Animal` with a method `speak()`. Then, create child classes `Dog` and `Cat` that inherit from `Animal` and override the `speak()` method. Provide an example of using these classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "753384d8-20bd-4a7d-9712-a0e7f5306369",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal :\n",
    "    \n",
    "    def speak(self):\n",
    "        return \"thise is speaking animals\"\n",
    "    \n",
    "class dog(Animal):\n",
    "    \n",
    "    def speak(self):\n",
    "        print(\"it is a speaking dog\")\n",
    "        \n",
    "class cat(dog,Animal):\n",
    "    \n",
    "    def speak(self):\n",
    "        print(\"Its a speaking cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dadc4fb0-9f08-4410-a7a5-cc09b84c7259",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_cat =cat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d8cd408a-0675-4a74-8fe5-4c005e1f2b62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Its a speaking cat\n"
     ]
    }
   ],
   "source": [
    "obj_cat.speak()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e86c659e-fe8e-4e68-86f8-a15b3999117c",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_dog =dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c7a137e4-2b97-4bee-b80d-e075d085e95e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it is a speaking dog\n"
     ]
    }
   ],
   "source": [
    "obj_dog.speak()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c8a0f634-df6c-485a-9a6c-f59929a4e996",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_animal =Animal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f18e59fa-17f2-4c88-9173-e21c965b4a52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'thise is speaking animals'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_animal.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57cad065-8b40-4ebb-9ca7-2d3dcdcacf28",
   "metadata": {},
   "source": [
    "8. Explain the role of the `isinstance()` function in Python and how it relates to inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99b753df-7999-4050-bfab-91e2cc619f6b",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    The isinstance() function in Python is a built-in function used for type checking. It verifies if an object is of a specified type, returning True if it is, and False otherwise. In this case, isinstance() returns True because x is an integer. Python has two built-in functions that work with inheritance: Use isinstance() to check an instance's type: isinstance(obj, int) will be True only if obj.__class__ is int or some class derived from int"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b706b07f-c6f8-429b-a7a3-077a4cf294be",
   "metadata": {},
   "source": [
    "9. What is the purpose of the `issubclass()` function in Python? Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73e0a735-2888-4ba2-9e7b-b74ea69e8808",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    The Python issubclass () is a built-in function that is used to check whether a class is the subclass of another class in the program or not"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c2a3417-f562-454d-981f-9adf7dfb65b4",
   "metadata": {},
   "source": [
    "10. Discuss the concept of constructor inheritance in Python. How are constructors inherited in child classes?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "141a5cc2-aa50-4177-8d5f-c5620c2ad8c9",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Constructor of subclasses always called to a constructor of parent class to initialize value for the attributes in the parent class, then it start assign value for its attributes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "240c146b-5094-48f2-8ba1-5eefeb358f25",
   "metadata": {},
   "source": [
    "11. Create a Python class called `Shape` with a method `area()` that calculates the area of a shape. Then, create child classes `Circle` and `Rectangle` that inherit from `Shape` and implement the `area()` method accordingly. Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "3220b442-1492-4db0-a055-ff01808151ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "class shape(object) :\n",
    "    \n",
    "    def area(self):\n",
    "        return \"It is calculte  the area of shape\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f850f7c8-e7b9-475e-b8c8-ea4784eb2a03",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle(shape):\n",
    "    \n",
    "    def area_of_circle(self , radious):\n",
    "        area_circle = 3.1412 *(radious**2)\n",
    "        return \"Area of circle :\",area_circle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3469055b-ffdc-439a-b13e-615f70885dfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "class rectangle(Circle):\n",
    "    \n",
    "    def area_of_rectangle(self ,length ,Widths):\n",
    "        area_rectangle = length * Widths\n",
    "        return \"the area of rectangle is:\",area_rectangle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "708dda7d-620c-4faa-b871-05e65c52d385",
   "metadata": {},
   "outputs": [],
   "source": [
    "pw_rectangle =rectangle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "413c3ea1-0c78-4fa9-a4f1-86cf2a348813",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'It is calculte  the area of shape'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw_rectangle.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "44e9e441-c254-4506-83e5-7e2996219321",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Area of circle :', 461.42468928)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw_rectangle.area_of_circle(12.12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "95b061ca-c7b3-4303-9273-7cc3737a7bde",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('the area of rectangle is:', 276)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw_rectangle.area_of_rectangle(12,23)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8641a6db-4846-4bc9-bc83-ee286ce8449f",
   "metadata": {},
   "source": [
    "12. Explain the use of abstract base classes (ABCs) in Python and how they relate to inheritance. Provide an example using the `abc` module."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94d554d8-c305-47a6-8825-fa71ed9fbd7c",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    In Python, you can create an abstract class using the abc module. This module provides the infrastructure for defining abstract base classes (ABCs). In this example, we import the ABC and abstractmethod from the abc module. We then define an abstract class AbstractClassExample using the ABC as the base class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "66416143-0450-4148-ace0-684ee9e60fd8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "area:  200\n"
     ]
    }
   ],
   "source": [
    "import abc\n",
    "class Shape(metaclass=abc.ABCMeta):\n",
    "    \n",
    "    @abc.abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, x,y):\n",
    "        self.l = x\n",
    "        self.b=y\n",
    "        \n",
    "    def area(self):\n",
    "        return self.l*self.b\n",
    "r = Rectangle(10,20)\n",
    "print ('area: ',r.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b399be02-3507-479b-a733-b7cde3d0f244",
   "metadata": {},
   "source": [
    "13. How can you prevent a child class from modifying certain attributes or methods inherited from a parent class in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dbded40-3816-46c7-9e9d-effa6dee0ba4",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Use double underscores ( __ ) before the attribute or method name. This will make the attribute or method private, and it will not be accessible to the child class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "067b000a-16e9-4b7a-9cce-24b0ef13b06f",
   "metadata": {},
   "source": [
    "### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7efb8985-e87d-4a19-a179-5456ee5d4351",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Child' object has no attribute '__name'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[3], line 13\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[38;5;66;03m# Child cannot access the __name attribute\u001b[39;00m\n\u001b[1;32m     12\u001b[0m child \u001b[38;5;241m=\u001b[39m Child()\n\u001b[0;32m---> 13\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mchild\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__name\u001b[49m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Child' object has no attribute '__name'"
     ]
    }
   ],
   "source": [
    "class Parent:\n",
    "    def __init__(self):\n",
    "        self.__name = \"Parent\"\n",
    "\n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "\n",
    "class Child(Parent):\n",
    "    pass\n",
    "\n",
    "# Child cannot access the __name attribute\n",
    "child = Child()\n",
    "print(child.__name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a38385e-6711-46e5-bd4d-32b9fb014200",
   "metadata": {},
   "source": [
    "14. Create a Python class called `Employee` with attributes `name` and `salary`. Then, create a child class `Manager` that inherits from `Employee` and adds an attribute `department`. Provide an example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a3a087f3-edd0-4f15-ac27-d06285f07bce",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee :\n",
    "    \n",
    "    def __init__(self ,name ,salery):\n",
    "        self.name =name\n",
    "        self.salery =salery"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "53617fcc-4b34-4b53-aca6-ae166736294f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Manager(Employee) :\n",
    "    \n",
    "    def __init__(self ,name ,salery ,department):\n",
    "        super().__init__(name ,salery)\n",
    "        self.department =department"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bfb48dc5-7a77-4cdd-9d66-105e90cb556f",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_Manger =Manager(\"Bhushan \",56000 ,\"Software\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6e97d927-af4e-4f8e-a59e-e5167fd4cbeb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Software'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_Manger.department"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "32aa8b9b-100b-42a8-940d-82e6336f2f7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bhushan '"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_Manger.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0beee198-d45e-4264-b18b-365495c3fa78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "56000"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_Manger.salery"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc058367-fa12-428c-b36b-e634a09b206f",
   "metadata": {},
   "source": [
    "15. Discuss the concept of method overloading in Python inheritance. How does it differ from method overriding?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af6b85f0-1b1a-4a12-ab99-e866be7a1ab7",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Overloading :\n",
    "    Method overloading is the ability to define multiple methods with the same name but different parameters. This is a common feature in many programming languages"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf49deb2-2b1c-49b1-801e-6e72aa537782",
   "metadata": {},
   "source": [
    "Overriding :\n",
    "    \n",
    "    Method overriding is the ability to redefine a method in a subclass that was originally defined in a superclass. This is a supported feature in Python, and it is a key part of object-oriented programming"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6649e78a-8d86-4b02-84af-f4c880188b5c",
   "metadata": {},
   "source": [
    "16. Explain the purpose of the `__init__()` method in Python inheritance and how it is utilized in child classes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22e6e5d4-49d6-4f9a-a07d-ea64e12b51ee",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    \n",
    "    The __init__() method in Python inheritance is used to initialize the attributes of a new object. It is called automatically whenever a new object is created."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13196f84-d6ff-4d79-89f2-3a626de4355f",
   "metadata": {},
   "source": [
    "Utilized in child class :\n",
    "    \n",
    "    The __init__() method of a child class can call the __init__() method of its parent class to initialize the parent class's attributes. This can be done using the super() function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed12d2c8-7b9a-472a-8bf0-5e40aba0cd1f",
   "metadata": {},
   "source": [
    "17. Create a Python class called `Bird` with a method `fly()`. Then, create child classes `Eagle` and `Sparrow` that inherit from `Bird` and implement the `fly()` method differently. Provide an example of using these classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "3844dd27-b290-4457-82fc-2b42e60a9635",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bird(object) :\n",
    "    \n",
    "    def fly(self):\n",
    "        print(\"I can fly in sky\")\n",
    "        \n",
    "class Eagle(Bird):\n",
    "    \n",
    "    def fly(self):\n",
    "        print(\"Eagle is fying high in sky\")\n",
    "        \n",
    "class Sparrow(Bird):\n",
    "    \n",
    "    def fly(self):\n",
    "        print(\"Sparrow is flitting from one tree to another tree\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "56d2536d-6ce0-4079-8055-c63f0ea10524",
   "metadata": {},
   "outputs": [],
   "source": [
    "Obj_Sparrow =Sparrow()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e9b9e45f-a883-4ca0-b930-6558ed30a888",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sparrow is flitting from one tree to another tree\n"
     ]
    }
   ],
   "source": [
    "Obj_Sparrow.fly()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "29102780-d9b3-4062-96b5-7c20f0fc59cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_Eagle =Eagle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "89240542-e21b-4f91-8769-e3f7f4b885c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eagle is fying high in sky\n"
     ]
    }
   ],
   "source": [
    "obj_Eagle.fly()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c4e40c70-9894-47a0-b31d-9de4dffd0b80",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_bird = Bird()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e6c3f2e6-dc5d-4394-9258-f0a14f6e10eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I can fly in sky\n"
     ]
    }
   ],
   "source": [
    "obj_bird.fly()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4942eedf-527b-4b0c-ac53-56a625d52788",
   "metadata": {},
   "source": [
    "18. What is the \"diamond problem\" in multiple inheritance, and how does Python address it?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06aaa78c-aa33-453b-a72e-10f605c195db",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    The diamond problem in multiple inheritance is a situation where a class inherits from two parent classes, and those parent classes have a method with the same name. When this happens, it is unclear which method the child class should inherit.\n",
    "\n",
    "Python addresses the diamond problem by using a method resolution order (MRO). The MRO is a list of classes that determines the order in which the Python interpreter searches for methods. The MRO is calculated based on the class hierarchy, and it ensures that the child class will always inherit the method from the closest parent class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6fc20e5-5230-4958-a793-68f27c98217e",
   "metadata": {},
   "source": [
    "19. Discuss the concept of \"is-a\" and \"has-a\" relationships in inheritance, and provide examples of each."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1bcf08b-6939-4d5d-b504-d372ec91fbba",
   "metadata": {},
   "source": [
    "20. Create a Python class hierarchy for a university system. Start with a base class `Person` and create child classes `Student` and `Professor`, each with their own attributes and methods. Provide an example of using these classes in a university context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d16561fc-58ba-4eaf-84ca-2ae455c5f060",
   "metadata": {},
   "outputs": [],
   "source": [
    "class person :\n",
    "    \n",
    "    def __init__(self, name ,age):\n",
    "        self.name = name\n",
    "        self.age =age\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1745770c-bafa-483a-8339-39110ca091ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "class student(person) :\n",
    "    \n",
    "    def __init__(self ,name ,age ,student_Id):\n",
    "        super().__init__(name ,age)\n",
    "        self.student_Id =student_Id\n",
    "        \n",
    "    def take_exam(self):\n",
    "        print(\"taking Exam\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "02753db2-c511-42b2-8acb-b0603060163f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class professor(person):\n",
    "    \n",
    "    def __init__(self ,name ,age ,department):\n",
    "        super().__init__(name ,age)\n",
    "        self.department =department\n",
    "        \n",
    "    def teach_class(self):\n",
    "        print(\"professor will teaches in class\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ab9dfc0a-f456-467c-aa0b-a1b50eb6ed60",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_professor = professor(\"Bhushan\" ,27 ,\"IT\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4230d90f-d878-4e1b-901b-cdc993d89e25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_professor.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "cf3c7c10-71fd-4874-ab1b-45c3007cb858",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'IT'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_professor.department"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "25d3603c-7f96-4b73-bb98-a6cb3e4a2da1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "professor will teaches in class\n"
     ]
    }
   ],
   "source": [
    "obj_professor.teach_class()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f8d592f2-d089-4b79-b01a-51c8ad84bae4",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_student =student(\"suyog\", 32 ,101)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "28a9ae19-4123-480c-8855-b8703df65ae3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "taking Exam\n"
     ]
    }
   ],
   "source": [
    "obj_student.take_exam()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3e713723-f740-4fa7-9224-4abe3ba8b185",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_student.student_Id"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef038947-1225-47d6-880c-523a6eaafc69",
   "metadata": {},
   "source": [
    "### Encapsulation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d785ab22-bf3e-4c36-8aea-09ab0816a26a",
   "metadata": {},
   "source": [
    "1. Explain the concept of encapsulation in Python. What is its role in object-oriented programming?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c68a9cb4-1f3e-46ac-bd00-0bbaabc1dc73",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Encapsulation is one of the key features of object-oriented programming. Encapsulation refers to the bundling of attributes and methods inside a single class. It prevents outer classes from accessing and changing attributes and methods of a class. This also helps to achieve data hiding"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c5086c6-d667-4f8a-8954-b846ced2b874",
   "metadata": {},
   "source": [
    "2. Describe the key principles of encapsulation, including access control and data hiding."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe01fd3e-a8fc-4be2-9c7f-510ea3166e53",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Encapsulation is a way to restrict the direct access to some components of an object, so users cannot access state values for all of the variables of a particular object. Encapsulation can be used to hide both data members and data functions or methods associated with an instantiated class or object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c72c9e6-56a2-4c22-8278-e572923b059f",
   "metadata": {},
   "source": [
    "3. How can you achieve encapsulation in Python classes? Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "701846f6-ce00-4cc7-8a0b-9a3d7617a34a",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Encapsulation is achieved by declaring a class's data members and methods as either private or protected. But in Python, we do not have keywords like public, private, and protected, as in the case of Java. Instead, we achieve this by using single and double underscores."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aef2bfc-bef4-4f1f-b529-51b4ebf52ec4",
   "metadata": {},
   "source": [
    "### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fa2defbf-880b-4e40-8bb5-ecb05eb7e7ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "class bank_account :\n",
    "    \n",
    "    def __init__(self,account_no , balance):\n",
    "        self.account_no =account_no\n",
    "        self.__balance =balance\n",
    "    \n",
    "    def check_balance(self ,password):\n",
    "        if password == \"Bhushan@1234\":\n",
    "            return \"Your current Balance :\",self.__balance \n",
    "        else:\n",
    "            return \"Wrong password\"    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8c07be02-6ae1-4e06-b6f8-7f132536d6a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_bank_account =bank_account(31944523534, 50000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0d1e5255-b467-4c4d-a2f5-93e7f6a2672b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "31944523534"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_bank_account.account_no"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "933604f6-fbe1-4bb1-a2a1-22acd3cea975",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Your current Balance :', 50000)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_bank_account.check_balance(\"Bhushan@1234\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e7d7583-49aa-40e0-830a-2e2fe36770eb",
   "metadata": {},
   "source": [
    "4. Discuss the difference between public, private, and protected access modifiers in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10c66abb-ea3c-444b-baa4-f4302de93245",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Pubilc :\n",
    "         \n",
    "        we can acesss public variable inside class as well as outside class. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f4dc72f-4697-4168-931a-e9762e85712f",
   "metadata": {},
   "source": [
    "Private variable :\n",
    "    \n",
    "    private variable can ascess inside class it cannot acess outside class. we can write private variable beyond (__) double underscore."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93ba54c8-d698-4369-9d2f-d12e43757070",
   "metadata": {},
   "source": [
    "Protected variable :\n",
    "    \n",
    "    Protected variables and methods are accessible within the specific class environment and can also be accessed by the sub-classes. We can also say that it allows the resources of the parent class to be inherited by the child class.Any variables or methods prefixed with a single underscore (_) in a class are protected and can be accessed within the specific class environment. The protected variables/methods can be accessed inside the sub-classes of the parent class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b11a148-ac6e-4770-b9b6-6bb161cfface",
   "metadata": {},
   "source": [
    "5. Create a Python class called `Person` with a private attribute `__name`. Provide methods to get and set the name attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "90fff893-33d7-4111-b4ab-4d71ec6abbe4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class person :\n",
    "    \n",
    "    def __init__(self ,name):\n",
    "        self.__name = name\n",
    "    \n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "    \n",
    "    def set_name(self ,setName):\n",
    "        self.__name =setName"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "91b447d6-c49c-44ae-b7f0-ef7528d942b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_person = person(\"Bhushan\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "dd3112a4-18bb-4657-9db4-1c78aaf792bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bhushan'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_person.get_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "484328f5-306a-403f-a7fc-90269853ff94",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_person.set_name(\"suyog\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "eb8d5527-c15e-4568-9a45-93677c58c31a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'suyog'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_person.get_name()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f6ad4d9-8169-4fd1-8176-aabf16a8303f",
   "metadata": {},
   "source": [
    "6. Explain the purpose of getter and setter methods in encapsulation. Provide examples."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1ac268f-7d83-4e72-b57e-cf27b037179a",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Getter method :\n",
    "        it is used to get method name from class . we have used @property  decorator for that."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35e2e8c9-a40d-4644-9a25-f1b7aedfc761",
   "metadata": {},
   "source": [
    "setter_method :\n",
    "    \n",
    "    setter method is used to maker changes in values of variable. we have used @getter_name.setter decorator for thise."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d97e842e-a137-4007-a85a-c0c3be617715",
   "metadata": {},
   "source": [
    "deleter method :\n",
    "    \n",
    "    thise method is used to delete the method from class. we have used @function_name.deleter as decorator for thise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "264c459a-f885-4724-a02f-15f5bfd3b8d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#example\n",
    "class person :\n",
    "    \n",
    "    def __init__(self ,name):\n",
    "        self.__name = name\n",
    "    \n",
    "    @property\n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "    \n",
    "    \n",
    "    def set_name(self ,setName):\n",
    "            self.__name =setName"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "85da781a-0ec6-4cea-bebb-6abbf62d9745",
   "metadata": {},
   "outputs": [],
   "source": [
    "Obj_person = person(\"bhushan\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "d931f5a9-fa10-4dd6-859c-69693ea81282",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bhushan'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Obj_person.get_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "e917678c-2e9b-436b-a2f4-80b9847d4f65",
   "metadata": {},
   "outputs": [],
   "source": [
    "Obj_person.set_name(\"suyog\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "b65be65d-696e-49c5-ac1c-bd65e5a51405",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'suyog'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Obj_person.get_name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef928d62-41ca-4ee3-8fe7-9425ac8edd92",
   "metadata": {},
   "source": [
    "7. What is name mangling in Python, and how does it affect encapsulation?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2514685c-09d1-4688-8cd7-ac497afc0bd3",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    In Python, mangling is used for class attributes that one does not want subclasses to use which are designated as such by giving them a name with two or more leading underscores and no more than one trailing underscore"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e63f292-f386-4830-9c85-a1e993e1a78d",
   "metadata": {},
   "source": [
    "8. Create a Python class called `BankAccount` with private attributes for the account balance (`__balance`) and account number (`__account_number`). Provide methods for depositing and withdrawing money."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ba82263c-1894-43ae-a9bb-b1470d4e2a59",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BankAccount :\n",
    "    \n",
    "    def __init__(self ,balance ,account_number):\n",
    "        self.__balance =balance\n",
    "        self.__account_number =account_number\n",
    "        \n",
    "        \n",
    "    def deposite_money(self ,deposite_amt):\n",
    "        self.__balance = self.__balance + deposite_amt\n",
    "        return \"You have deposited\",self.__balance\n",
    "    \n",
    "    def withdraw_money(self ,withdraw_amt):\n",
    "        self.__balance = self.__balance - withdraw_amt\n",
    "        return \"You have Withdraw\",self.__balance\n",
    "    \n",
    "    def Available_Balance(self):\n",
    "        print(\"Your current balance is :\",self.__balance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cfb51d57-0b6d-49eb-b271-d6049c75fe21",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_bankAccount =BankAccount(50000 ,123456789)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4d4a077c-3d1d-4c30-b363-a029975af237",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('You have deposited', 52000)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_bankAccount.deposite_money(2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e791e423-6027-464b-a5ae-a3456b593474",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52000"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_bankAccount._BankAccount__balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8333fe79-6064-41ec-96d0-875e464fe125",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('You have Withdraw', 50000)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_bankAccount.withdraw_money(2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "abb5c290-382e-4b16-8185-889e106023aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your current balance is : 50000\n"
     ]
    }
   ],
   "source": [
    "obj_bankAccount.Available_Balance()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7ce6949-b102-4e0f-bbb8-0e29ef6bb80a",
   "metadata": {},
   "source": [
    "9. Discuss the advantages of encapsulation in terms of code maintainability and security"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dc9b9fc-92fc-4c80-bd52-6c63cfe89e9f",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    It helps in writing more robust, maintainable, and secure code. Encapsulation promotes encapsulating data and behavior within classes, allowing controlled access to the data through methods and enforcing validation and business logic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "227c4bc1-7cda-45e0-b4bc-cc4822ba366e",
   "metadata": {},
   "source": [
    "10. How can you access private attributes in Python? Provide an example demonstrating the use of name mangling."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13ee045e-b22d-4192-bbfa-c97b9bd7da35",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    The class variables can be accessed by adding _classname to it. The name mangling is closest to private not exactly private. The above class variable is accessed by adding the _classname to it. The class variable is accessed from outside the class with the name _Student__name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82d0b226-6373-417d-a80f-29f6f83684a5",
   "metadata": {},
   "source": [
    "Example :\n",
    "    \n",
    "    object_name._classname__variablename"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fbdef36-022c-4bb8-a5e4-da311a47f04d",
   "metadata": {},
   "source": [
    "11. Create a Python class hierarchy for a school system, including classes for students, teachers, and courses, and implement encapsulation principles to protect sensitive information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "20581d7e-0c8e-4f4a-bd4c-3daee9dae424",
   "metadata": {},
   "outputs": [],
   "source": [
    "class student :\n",
    "    \n",
    "    def __init__(self ,name ,sirname ,student_id):\n",
    "        self._name =name\n",
    "        self._sirname =sirname\n",
    "        self._student_id =student_id\n",
    "        \n",
    "    def show_student_details(self):\n",
    "        return self._name ,self._sirname ,self._student_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "195b104b-e4ce-47ac-9750-d484f756fb31",
   "metadata": {},
   "outputs": [],
   "source": [
    "class teacher(student):\n",
    "    \n",
    "    def __init__(self ,name ,sirname ,student_id ,employee_id):\n",
    "        super().__init__(name ,sirname ,student_id)\n",
    "        self._employee_id = employee_id\n",
    "        \n",
    "    def show_employee_id(self):\n",
    "        return self._employee_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "4868c654-9ca3-492b-8e84-12fa35b5fa6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class courses(teacher) :\n",
    "    \n",
    "    def Courses_Show(self):\n",
    "        return [\"Big Data\",\"Data analytics\",\"FSDS\",\"Machine leaning\",\"web developement\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "b34fc4c7-29e4-4e63-b7ba-c8009f7b1c3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_course =courses(\"Bhushan\",\"Chopade\",101, 10809)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "e5d6f704-b633-4b36-8097-7dedfca3a842",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Big Data', 'Data analytics', 'FSDS', 'Machine leaning', 'web developement']"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_course.Courses_Show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "a39606f3-b6e8-45f7-9871-eaea145db9ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10809"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_course.show_employee_id()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "bfda7bb7-3655-440c-b9c8-ae0209315efe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Bhushan', 'Chopade', 101)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_course.show_student_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db994d5a-9a19-4aca-9056-f28bca9a2148",
   "metadata": {},
   "source": [
    "12. Explain the concept of property decorators in Python and how they relate to encapsulation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3ec4abf-6ad8-4f38-a0df-fbbb89e7ec8d",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    \n",
    "Property decorators in Python are used to define properties, which are special methods that can be used to get, set, and delete attributes of an object. Properties are defined using the @property decorator, and they can be used to implement encapsulation principles in Python.\n",
    "\n",
    "Encapsulation is the process of hiding the implementation details of an object from the outside world. This can be done by making the object's attributes private, and by providing public methods to access and modify those attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea63dd8a-bfc0-4a39-b1c4-d0ca1068166e",
   "metadata": {},
   "source": [
    "13. What is data hiding, and why is it important in encapsulation? Provide examples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41f09fb0-7078-4d80-8e55-fedd711f3e56",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Data hiding is a technique used in object-oriented programming to protect the internal data of a class from unauthorized access. It is implemented by making the class's data members private and providing public methods to access and modify them. This allows the programmer to control how the data is used and to prevent it from being corrupted or accidentally modified."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c1f07f0-dd54-4a9a-8bd0-73f6ae4d1546",
   "metadata": {},
   "source": [
    "Data hiding is important in encapsulation because it helps to:\n",
    "\n",
    "`Protect sensitive data`: By hiding the class's data members, we can prevent unauthorized users from accessing or modifying them. This is especially important for sensitive data such as student grades or teacher salaries.\n",
    "\n",
    "`Prevent data corruption:` By controlling how the data is accessed and modified, we can help to prevent it from being corrupted. For example, we can prevent users from setting a student's grade to a negative value.\n",
    "\n",
    "`Improve maintainability:` By hiding the class's internal implementation details, we make it easier to maintain the code. For example, we can change the way the data is stored without affecting the way the class is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9d50295e-4a99-452b-817e-1ea88c864490",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BankAccount :\n",
    "    \n",
    "    def __init__(self ,balance ,account_number):\n",
    "        self.__balance =balance\n",
    "        self.__account_number =account_number\n",
    "        \n",
    "        \n",
    "    def deposite_money(self ,deposite_amt):\n",
    "        self.__balance = self.__balance + deposite_amt\n",
    "        return \"You have deposited\",self.__balance\n",
    "    \n",
    "    def withdraw_money(self ,withdraw_amt):\n",
    "        self.__balance = self.__balance - withdraw_amt\n",
    "        return \"You have Withdraw\",self.__balance\n",
    "    \n",
    "    def Available_Balance(self):\n",
    "        print(\"Your current balance is :\",self.__balance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "edf80627-70cc-49ed-8d01-6212b0d22b1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_bank =BankAccount(5000 ,765324765435)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a11e2716-617f-4ae5-b402-04e244d239d2",
   "metadata": {},
   "source": [
    "14. Create a Python class called `Employee` with private attributes for salary (`__salary`) and employee ID (`__employee_id`). Provide a method to calculate yearly bonuses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8c8737ff-1845-4280-8b18-9817dd50b42e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee :\n",
    "    \n",
    "    def __init__(self ,salery ,employee_id):\n",
    "        self.__salery =salery\n",
    "        self.__employee_id =employee_id\n",
    "        \n",
    "    def calculate_yearly_bonus(self):\n",
    "        print(\"Yearly bonus is :\",self.__salery /2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f6ce4148-7806-405e-9f76-2dad40ad1c3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_employee =Employee(50000 ,102021)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2cc21ca3-d3ff-49b6-8fe2-07490a8a0cc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yearly bonus is : 25000.0\n"
     ]
    }
   ],
   "source": [
    "obj_employee.calculate_yearly_bonus()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2040a0b9-6687-46b3-af32-648ce45204f6",
   "metadata": {},
   "source": [
    "15. Discuss the use of accessors and mutators in encapsulation. How do they help maintain control over attribute access?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27441133-a880-4978-b86b-9c4f671af6c1",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Accessors and mutators are methods that are used to get and set the values of private attributes in a class. They are essential for encapsulation, which is a programming principle that allows us to hide the internal implementation of a class from other classes.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12e3e9c3-929c-40af-9ca5-c8c34eb25a2f",
   "metadata": {},
   "source": [
    "\n",
    "Accessors and mutators are methods that are used to get and set the values of private attributes in a class. They are essential for encapsulation, which is a programming principle that allows us to hide the internal implementation of a class from other classes.\n",
    "\n",
    "Encapsulation has many benefits, including:\n",
    "\n",
    "`Data protection:` By making attributes private and only accessible through accessors and mutators, we can prevent other classes from accidentally or maliciously modifying our data.\n",
    "Modularity: Encapsulation allows us to design classes that are independent of each other. This makes our code more reusable and maintainable.\n",
    "\n",
    "`Abstraction:` Encapsulation allows us to hide the complexity of our code from other classes. This makes our code easier to understand and use.\n",
    "Accessors and mutators help us maintain control over attribute access in the following ways:\n",
    "\n",
    "They allow us to validate input: Before setting the value of an attribute, we can use the mutator method to validate the input to make sure that it is valid. For example, we could check that a grade is between 0 and 100 before setting it.\n",
    "\n",
    "They allow us to perform additional operations: Before or after getting or setting the value of an attribute, we can use the accessor or mutator method to perform additional operations. For example, we could log the access or modification of an attribute.\n",
    "They allow us to restrict access to certain attributes: We can choose to only provide an accessor or mutator method for certain attributes, making them read-only or write-only. This can be useful for protecting sensitive data or for preventing other classes from modifying the state of our object in an unexpected way."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acdfabd1-bd9f-4a57-9806-16f761cb7a1b",
   "metadata": {},
   "source": [
    "16. What are the potential drawbacks or disadvantages of using encapsulation in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "599228b2-0efa-4ae8-a64e-1ada93499ba3",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Disadvantages of Encapsulation\n",
    "Increased code execution: Encapsulation results in an increase in the duration of the program execution. It is because more instructions are added to the code therefore they require more time to execute"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "158fc1f3-7a88-4629-907c-2bf914899fa6",
   "metadata": {},
   "source": [
    "17. Create a Python class for a library system that encapsulates book information, including titles, authors, and availability status."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2a51c745-0190-4cad-9dbf-c8b76ac18a24",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Book:\n",
    "    \"\"\"Class for books in a library system.\"\"\"\n",
    "\n",
    "    def __init__(self, title, author, availability_status):\n",
    "        self._title = title\n",
    "        self._author = author\n",
    "        self._availability_status = availability_status\n",
    "\n",
    "    @property\n",
    "    def title(self):\n",
    "        return self._title\n",
    "\n",
    "    @property\n",
    "    def author(self):\n",
    "        return self._author\n",
    "\n",
    "    @property\n",
    "    def availability_status(self):\n",
    "        return self._availability_status\n",
    "\n",
    "    @availability_status.setter\n",
    "    def availability_status(self, new_availability_status):\n",
    "        if new_availability_status not in [\"available\", \"checked out\"]:\n",
    "            raise ValueError(\"Availability status must be either 'available' or 'checked out'.\")\n",
    "        self._availability_status = new_availability_status\n",
    "\n",
    "    def check_out(self):\n",
    "        if self._availability_status == \"available\":\n",
    "            self._availability_status = \"checked out\"\n",
    "        else:\n",
    "            raise ValueError(\"Book is not available for checkout.\")\n",
    "\n",
    "    def return_book(self):\n",
    "        if self._availability_status == \"checked out\":\n",
    "            self._availability_status = \"available\"\n",
    "        else:\n",
    "            raise ValueError(\"Book is already available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5c9db312-decc-4e15-979a-4d4f35353129",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_book =Book(\"The Hitchhiker's Guide to the Galaxy\", \"Douglas Adams\", \"available\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "17e1b90d-ef35-41ed-a774-fa5194baff0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Douglas Adams'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_book.author"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d846734d-593a-47db-a266-54184f0ac062",
   "metadata": {},
   "source": [
    "18. Explain how encapsulation enhances code reusability and modularity in Python programs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53e6f2dc-52e1-477a-ac50-b58b7bc2abe5",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    By restricting direct access to an object's attributes, we avoid unintentional data manipulation and expose only necessary functionalities. Modularity and Reusability: By bundling related data and functionality into classes, we achieve modularity, making it simple to understand, refactor, and reuse code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b8ff5b8-7aa4-4240-87f6-d63107ae2974",
   "metadata": {},
   "source": [
    "19. Describe the concept of information hiding in encapsulation. Why is it essential in software development?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10952df9-0a19-41cf-840c-1cbca0907269",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    What is encapsulation and information hiding in software design?\n",
    "Encapsulation means grouping software into units in such a way that it is easy to use with well-defined simple interfaces. Encapsulation and information hiding are related to each other, since both have a goal of making classes easier to use."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca2337cf-fca2-44fd-9aa6-8c9e3508f7b5",
   "metadata": {},
   "source": [
    "20. Create a Python class called `Customer` with private attributes for customer details like name, address, and contact information. Implement encapsulation to ensure data integrity and security."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "44f4c12d-8e72-45cd-b993-ef1be1849653",
   "metadata": {},
   "outputs": [],
   "source": [
    "class customer :\n",
    "    \n",
    "    def __init__(self ,cust_name ,address ,contact_info):\n",
    "        self.__cust_name =cust_name \n",
    "        self.__address =address\n",
    "        self.__contact_info =contact_info\n",
    "        \n",
    "    def customer_name(self):\n",
    "        return self.__cust_name\n",
    "    \n",
    "    def customer_address(self):\n",
    "        return self.__address\n",
    "    \n",
    "    def cust_contact_info(self):\n",
    "        return self.__contact_info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "d7a590ee-552b-45c4-a5a4-5b64dfa0b25d",
   "metadata": {},
   "outputs": [],
   "source": [
    "pw_obj_customer =customer(\"Pwskills \",\"pune\",8987664588)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "05a04649-7236-4ba7-9576-e1722342caf5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8987664588"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw_obj_customer.cust_contact_info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "32edcce1-f38a-4ae3-ad9c-39f8962b8500",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pune'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw_obj_customer.customer_address()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "ca8bcd6a-4684-488d-9dc1-78f14f4d99b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pwskills '"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw_obj_customer.customer_name()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56919729-ecaf-42a9-a435-a530dc7a7e38",
   "metadata": {},
   "source": [
    "### Polymorphism:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ed0034e-8143-4a76-87ce-a522d07e8020",
   "metadata": {},
   "source": [
    "1. What is polymorphism in Python? Explain how it is related to object-oriented programming."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a8d6e11-1f07-4350-b57f-f44925809cd7",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    In polymorphism the function behave like as per the data.Polymorphism is often used in Class methods, where we can have multiple classes with the same method name."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "150eb803-dd50-4e38-978a-0c331132eab4",
   "metadata": {},
   "source": [
    "2. Describe the difference between compile-time polymorphism and runtime polymorphism in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91b2e9a4-06ec-4f00-bd0b-fdd64ee3bf89",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    \n",
    "    Compile-time polymorphism is a type of polymorphism where the compiler determines which method to call based on the type of arguments passed to the method. This is also known as method overloading."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed17cf9f-b5ba-4794-ba97-1caddd690394",
   "metadata": {},
   "source": [
    "   \n",
    "    \n",
    "    Runtime polymorphism is a type of polymorphism where the compiler does not know which method to call until runtime. This is also known as method overriding."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "775eda54-8e70-4b34-947e-c6563dafe0ab",
   "metadata": {},
   "source": [
    "3. Create a Python class hierarchy for shapes (e.g., circle, square, triangle) and demonstrate polymorphism through a common method, such as `calculate_area()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ccde6227-f327-4944-ad95-0da01d6fd79f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class shape :\n",
    "    \n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "    def calculate_area(self):\n",
    "        return \"calculate the area of shape\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2d584934-0cf5-414b-8753-dd29bb1c0b09",
   "metadata": {},
   "outputs": [],
   "source": [
    "class circle(shape):\n",
    "    \n",
    "    def __init__(self ,radious):\n",
    "        super().__init__()\n",
    "        self.radious =radious\n",
    "        \n",
    "    def calculate_area(self):\n",
    "        return 3.14 * (self.radious**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "98f0a60c-f372-40c9-ac26-f893b056b781",
   "metadata": {},
   "outputs": [],
   "source": [
    "class square(shape):\n",
    "    \n",
    "    def __init__(self ,side_length):\n",
    "        super().__init__()\n",
    "        self.side_length =side_length\n",
    "        \n",
    "    def calculate_area(self):\n",
    "        return self.side_length **2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "163d34fa-953f-4cd9-b109-3cf1713deb9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class triangle(shape):\n",
    "    \n",
    "    def __init__(self ,base ,height):\n",
    "        super().__init__()\n",
    "        self.base =base\n",
    "        self.height =height\n",
    "        \n",
    "    def calculate_area(self):\n",
    "        return 0.5 * self.base *self.height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "71c4ef9a-8fb8-4d2e-aad9-f087ceee8b9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_triangle =triangle(12.23 , 23.34)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ce3f8607-bae8-4b12-b796-3431601c12cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "142.7241"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_triangle.calculate_area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8f7ddb6a-457f-4d84-a795-c56f3bd768a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_square =square(12.45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3b7beb65-f1c7-41e6-8f16-f1376625929c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.45"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_square.side_length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "19e348aa-6f34-4428-8583-da2309e5f157",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "155.00249999999997"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_square.calculate_area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e65d312c-cb8d-4ef6-9614-1d99132f446c",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_circle =circle(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "36cfdda2-8849-4fd3-a3e0-d01da4bc15d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.24"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_circle.calculate_area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c8732510-32fe-4516-a152-46618d9156d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_shape =shape()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "66a24dd6-5722-4cb8-af66-d6879788d6bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'calculate the area of shape'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_shape.calculate_area()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01b956dd-3c39-4815-ad0e-2902193141a5",
   "metadata": {},
   "source": [
    "4. Explain the concept of method overriding in polymorphism. Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcb59afb-25a0-4fe8-9f02-70044d511ec6",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Method Overriding is done when a child or a subclass has a method with the same name, parameters, and return type as the parent or the superclass; then that function overrides the function in the superclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c16c9792-5ec7-45b4-a941-576ae444a024",
   "metadata": {},
   "outputs": [],
   "source": [
    "class data_science :\n",
    "    \n",
    "    def syllabus(self):\n",
    "        print(\"Thise is data science master syllabus\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "005b2ab9-9653-480a-964d-6800abd5ace7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class web_development :\n",
    "    \n",
    "    def syllabus(self):\n",
    "        print(\"Thise is web development syllabus\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "1d131c6b-9caf-4d6c-8783-81363eaf76fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def parcer(class_obj):\n",
    "    for i in class_obj:\n",
    "        i.syllabus()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "0fc53763-5706-46f6-a4b8-1bc881e7900c",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_dataScience =data_science()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "46d0984c-edf3-4876-8542-8c361ec755f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thise is data science master syllabus\n"
     ]
    }
   ],
   "source": [
    "obj_dataScience.syllabus()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "fd68da15-cb46-4569-818b-53a9a8c75b62",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_web_dev =web_development()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "04ca1e5b-8c2a-4290-b471-299c18335ef3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thise is web development syllabus\n"
     ]
    }
   ],
   "source": [
    "obj_web_dev.syllabus()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "7007d03c-4d93-4594-9e0a-045244b0f0c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class_obj = [obj_dataScience ,obj_web_dev]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "c646229c-eea2-446f-bd27-a026f61e55d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thise is data science master syllabus\n",
      "Thise is web development syllabus\n"
     ]
    }
   ],
   "source": [
    "parcer(class_obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c8ac77b-ecef-4504-aee0-91be0cb42d29",
   "metadata": {},
   "source": [
    "5. How is polymorphism different from method overloading in Python? Provide examples for both."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f152a57f-69b7-48f9-b022-d2a47b106843",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Method Overloading in Python is a type of Compile-time Polymorphism using which we can define two or more methods in the same class with the same name but with a different parameter list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c7f0bead-a473-4278-b502-215941e6f6c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi\n",
    "class square:\n",
    "    def __init__(self, length):\n",
    "        self.l = length\n",
    "        \n",
    "    def perimeter(self):\n",
    "        return 4 * (self.l)\n",
    "    \n",
    "    def area(self):\n",
    "        return self.l * self.l\n",
    "    \n",
    "    \n",
    "class Circle:\n",
    "    \n",
    "    def __init__(self, radius):\n",
    "        self.r = radius\n",
    "        \n",
    "    def perimeter(self):\n",
    "        return 2 * pi * self.r\n",
    "    \n",
    "    def area(self):\n",
    "        return pi * self.r ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ac0f23e7-0655-4568-a3a8-dfc44da6ae54",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_radious_circle =Circle(14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a7a5e189-ea48-4eae-b620-299ab5aa9473",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "615.7521601035994"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_radious_circle.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3af765c1-75aa-49c9-a799-77c5132a765d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "87.96459430051421"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_radious_circle.perimeter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f587a48b-e4fb-41db-b687-5928932942ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_radious_circle.r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d35154d2-777b-4245-ad4c-1c5698f67e74",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_square =square(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "663866f4-bd69-4af8-a0c7-29621f035d19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_square.perimeter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "11c1db2a-797d-4dc9-bd6d-42236d31d7ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_square.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "679982ff-eb0a-499f-9292-a1ab4bc1cdeb",
   "metadata": {},
   "source": [
    "6. Create a Python class called `Animal` with a method `speak()`. Then, create child classes like `Dog`, `Cat`, and `Bird`, each with their own `speak()` method. Demonstrate polymorphism by calling the `speak()` method on objects of different subclasses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "40b3cab4-c992-4a46-a270-e10b0dcd4316",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal :\n",
    "    \n",
    "    def speak(self):\n",
    "        print(\"Animal cannot speak \")\n",
    "        \n",
    "class Dog(Animal):\n",
    "    \n",
    "    def speak(self):\n",
    "        print(\"Dog Cannot speak\")\n",
    "        \n",
    "class Cat(Animal):\n",
    "    \n",
    "    def speak(self):\n",
    "        print(\"Cat have different voice\")\n",
    "        \n",
    "class Bird(Animal):\n",
    "    \n",
    "    def speak(self):\n",
    "        print(\"Bird cannot speak\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2d463cea-65cb-4a52-abde-8b1b0722a6b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bird cannot speak\n"
     ]
    }
   ],
   "source": [
    "obj_Bird =Bird()\n",
    "obj_Bird.speak()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fe0e261d-da2f-479f-8295-b0ebcf72783c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cat have different voice\n"
     ]
    }
   ],
   "source": [
    "obj_cat =Cat()\n",
    "obj_cat.speak()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1af14b41-2c3d-48b8-803e-fce30b751fd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog Cannot speak\n"
     ]
    }
   ],
   "source": [
    "obj_Dog =Dog()\n",
    "obj_Dog.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de192f40-c4cc-45b1-8df9-cba71f95b94b",
   "metadata": {},
   "source": [
    "7. Discuss the use of abstract methods and classes in achieving polymorphism in Python. Provide an example using the `abc` module."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "384e7f56-0772-4b19-a991-e26b9616831f",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    To use Python Abstract Base Classes (ABCs), one needs to import ABCMeta and abstractmethod from the abc module. For example,let us examine the class Shape and its subclasses Rectangle and Circle defined in the script shape . Each of the subclasses Rectangle and Circle needs methods for computing area and perimeter\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "092d86b6-0093-4fe9-a982-7eaa0bd18ae0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Animal(ABC):\n",
    "    \"\"\"Abstract base class for all animals.\"\"\"\n",
    "\n",
    "    @abstractmethod\n",
    "    def make_sound(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "class Dog(Animal):\n",
    "    \n",
    "    def make_sound(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Meow!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "02202942-4c8d-48fe-88d0-5018907e62d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "bj_cat =Cat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "bcf68cfd-b22a-4ce2-a71d-2abecab9c4b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "bj_cat.make_sound()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "262ca83b-913d-462f-a0fb-b6d3efd75d6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n"
     ]
    }
   ],
   "source": [
    "obj_dog =Dog()\n",
    "obj_dog.make_sound()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16c42f8c-1ff6-48fc-961a-7555d95eceb0",
   "metadata": {},
   "source": [
    "8. Create a Python class hierarchy for a vehicle system (e.g., car, bicycle, boat) and implement a polymorphic `start()` method that prints a message specific to each vehicle type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d1561706-0ff6-4ce3-962b-be9ec67db82b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vehicle:\n",
    "    \"\"\"Base class for all vehicles.\"\"\"\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def start(self):\n",
    "        raise NotImplementedError()\n",
    "\n",
    "class Car(Vehicle):\n",
    "    \"\"\"Class for cars.\"\"\"\n",
    "\n",
    "    def start(self):\n",
    "        print(f\"The car {self.name} engine starts.\")\n",
    "\n",
    "class Bicycle(Vehicle):\n",
    "    \"\"\"Class for bicycles.\"\"\"\n",
    "\n",
    "    def start(self):\n",
    "        print(f\"The cyclist starts pedaling the {self.name}.\")\n",
    "\n",
    "class Boat(Vehicle):\n",
    "    \"\"\"Class for boats.\"\"\"\n",
    "\n",
    "    def start(self):\n",
    "        print(f\"The boat {self.name} engine starts.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4994d086-23c3-4fee-8eb5-548b6a90e6f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = Car(\"Toyota Camry\")\n",
    "bicycle = Bicycle(\"Trek Marlin 5\")\n",
    "boat = Boat(\"Sea Ray 210 SPX\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "7162932b-6bc5-4a0d-aaab-68f424f8dc66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Toyota Camry'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "61b21af7-4f15-41ce-a32b-5535459745bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The car Toyota Camry engine starts.\n"
     ]
    }
   ],
   "source": [
    "car.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8bcab7dc-514e-45b3-9b73-eb79f9fd158f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cyclist starts pedaling the Trek Marlin 5.\n"
     ]
    }
   ],
   "source": [
    "bicycle.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1d5067e9-5c65-47c8-8c08-edf23c827e4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The boat Sea Ray 210 SPX engine starts.\n"
     ]
    }
   ],
   "source": [
    "boat.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34df293a-7004-4780-a0af-cb36cd977c16",
   "metadata": {},
   "source": [
    "9. Explain the significance of the `isinstance()` and `issubclass()` functions in Python polymorphism"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1552d262-f7f7-4387-9d50-d0c70ba96377",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    The function isinstance () checks whether the object that is passed in its parameters is the subclass of the classinfo mentioned within the parameters. On the other hand, the Python issubclass () function only checks whether a class is a subclass of a supposed parent class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a28f38a4-ce6c-4345-9093-3311968163ab",
   "metadata": {},
   "source": [
    "10. What is the role of the `@abstractmethod` decorator in achieving polymorphism in Python? Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db51d71c-9ed0-4c49-bf34-ce23bbe2c72d",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    The @abstractmethod decorator in Python is used to declare abstract methods. An abstract method is a method that has a declaration but does not have an implementation. Subclasses of a class that contains abstract methods must implement all of the abstract methods in order to be instantiated.\n",
    "\n",
    "    The @abstractmethod decorator helps to achieve polymorphism in Python by allowing us to define a common interface for a group of related classes. This allows us to write code that can work with different types of objects without having to know the specific details of each type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "1e575669-d9e3-4ca8-bec7-8fdf8589040c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Animal(ABC):\n",
    "    \"\"\"Abstract base class for all animals.\"\"\"\n",
    "\n",
    "    @abstractmethod\n",
    "    def make_sound(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "class Dog(Animal):\n",
    "    \n",
    "    def make_sound(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Meow!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "2fba5191-709a-42af-bf86-140de9f06748",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_cat =Cat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "12e8480e-d171-4d40-aa66-7152afc64d9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "obj_cat.make_sound()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "4a21fe7f-ebd6-4ece-96b1-88b5d7e9959f",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_Dog =Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "4bc843c6-a00f-409d-9b12-0dfb430ea6bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n"
     ]
    }
   ],
   "source": [
    "obj_Dog.make_sound()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1536acc7-6fee-4b42-b843-794dbe1837d2",
   "metadata": {},
   "source": [
    "11. Create a Python class called `Shape` with a polymorphic method `area()` that calculates the area of different shapes (e.g., circle, rectangle, triangle)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "a864d685-8f6b-4d98-8070-09e2c1296f0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class shape :\n",
    "    \n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "    def calculate_area(self):\n",
    "        return \"calculate the area of shape\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "77a91277-3302-467a-8da4-6614700fcc3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class circle(shape):\n",
    "    \n",
    "    def __init__(self ,radious):\n",
    "        super().__init__()\n",
    "        self.radious =radious\n",
    "        \n",
    "    def calculate_area(self):\n",
    "        return 3.14 * (self.radious**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ae93d914-6328-4f5b-bd33-bae0c78aa41d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle(shape):\n",
    "    \n",
    "    def __init__(self ,length ,width):\n",
    "        super().__init__()\n",
    "        self.length =length\n",
    "        self.width =width\n",
    "        \n",
    "    def calculate_area(self):\n",
    "        return self.length * self.width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "521f8609-2015-4b56-942b-b05b8350e18f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class triangle(shape):\n",
    "    \n",
    "    def __init__(self ,base ,height):\n",
    "        super().__init__()\n",
    "        self.base =base\n",
    "        self.height =height\n",
    "        \n",
    "    def calculate_area(self):\n",
    "        return 0.5 * self.base *self.height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "b24fd593-846b-4f89-8768-8e803b4dc9de",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_triangle =triangle(10 ,12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "81cfb61d-ac38-4e2b-9081-6467ff76256e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60.0"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_triangle.calculate_area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "772d05ab-ff57-4412-8d69-6e2b30e75ce8",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_rectangle =Rectangle(20,30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "3a8dda96-93e4-4d65-aaef-359b59694e08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "600"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_rectangle.calculate_area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "54680f95-7451-49c8-abe3-8581d990d96d",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_circle =circle(23)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "00fb3504-4fcf-4042-a5ed-48687825d481",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1661.0600000000002"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_circle.calculate_area()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9e76336-66ac-4ac5-8fb8-778a188707fb",
   "metadata": {},
   "source": [
    "12. Discuss the benefits of polymorphism in terms of code reusability and flexibility in Python programs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ace164c1-8fae-4875-a2ff-77f87fc798bf",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Code Reusability: Polymorphism allows you to reuse the code written for the base class, reducing redundancy and promoting cleaner, more concise code.\n",
    "    \n",
    "    Flexibility and Extensibility: With polymorphism, you can add new derived classes without modifying existing code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41e3e449-4695-4df6-a4b2-efeb3c6658ed",
   "metadata": {},
   "source": [
    "13. Explain the use of the `super()` function in Python polymorphism. How does it help call methods of parent classes?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1be57eb3-be2f-4e59-b112-1641f1b2ed3f",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    In Python, the super() function is used to refer to the parent class or superclass. It allows you to call methods defined in the superclass from the subclass, enabling you to extend and customize the functionality inherited from the parent class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "404a3e3a-5ba1-4193-a1fb-0eb0f35faa14",
   "metadata": {},
   "source": [
    "14. Create a Python class hierarchy for a banking system with various account types (e.g., savings, checking, credit card) and demonstrate polymorphism by implementing a common `withdraw()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "4c621766-9af2-406a-9d0c-9378d6ac09da",
   "metadata": {},
   "outputs": [],
   "source": [
    "class banking :\n",
    "    \n",
    "    def withdraw(self):\n",
    "        print(\"Withdraw money \")\n",
    "        \n",
    "        \n",
    "class saving(banking):\n",
    "    \n",
    "    def withdraw(self):\n",
    "        print(\"Thse is saving account \")\n",
    "        \n",
    "class checking(banking):\n",
    "    \n",
    "    def withdraw(self):\n",
    "        print(\"thise will use for balance checking\")\n",
    "        \n",
    "class credit_card(banking):\n",
    "    \n",
    "    def withdraw(self):\n",
    "        print(\"thise is credit card purpose\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "cb630983-dd90-49c8-8ebe-879c155bbd9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_creditcard =credit_card()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "97353e26-b817-41a3-8bca-b74a8982359b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "thise is credit card purpose\n"
     ]
    }
   ],
   "source": [
    "obj_creditcard.withdraw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "ea04a31a-7358-4609-84ad-da1a76215eb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "thise will use for balance checking\n"
     ]
    }
   ],
   "source": [
    "obj_checking =checking()\n",
    "obj_checking.withdraw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "4f940d9c-4efa-4cdb-a421-2825a6e7aea0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thse is saving account \n"
     ]
    }
   ],
   "source": [
    "obj_saqving =saving()\n",
    "obj_saqving.withdraw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "b3f300fa-3648-4c74-a3c4-5f81a0a3be5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Withdraw money \n"
     ]
    }
   ],
   "source": [
    "obj_banking =banking()\n",
    "obj_banking.withdraw()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5849cbe1-bd0e-4198-b1f9-5c17ac44a30e",
   "metadata": {},
   "source": [
    "15. Describe the concept of operator overloading in Python and how it relates to polymorphism. Provide examples using operators like `+` and `*`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6acae03b-18b7-418d-9b33-b146bc0fe1e9",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Operator Overloading means giving extended meaning beyond their predefined operational meaning. For example operator + is used to add two integers as well as join two strings and merge two lists. It is achievable because ‘+’ operator is overloaded by int class and str class. You might have noticed that the same built-in operator or function shows different behavior for objects of different classes, this is called Operator Overloading. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "773fde28-d1da-4884-bdaf-b6ac04ec8a43",
   "metadata": {},
   "source": [
    "16. What is dynamic polymorphism, and how is it achieved in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59f4feb4-62e5-456f-b9cd-8ac342806f5c",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    In Python, Polymorphism lets us define methods in the child class that have the same name as the methods in the parent class. In inheritance, the child class inherits the methods from the parent class. However, it is possible to modify a method in a child class that it has inherited from the parent class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a700a5c-e319-422b-98c1-aba93d0d6ddb",
   "metadata": {},
   "source": [
    "17. Create a Python class hierarchy for employees in a company (e.g., manager, developer, designer) and implement polymorphism through a common `calculate_salary()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "ec5ca7a3-bf92-48e7-b4a9-d834c74cc6aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "class employee :\n",
    "    \n",
    "    def __init__(self ,salery):\n",
    "        self.salery =salery\n",
    "        \n",
    "    def calculate_salery(self):\n",
    "        return \"calculated salery\"\n",
    "    \n",
    "class manager(employee) :\n",
    "    \n",
    "    def calculate_salery(self):\n",
    "        print(\"Manager salery is :\",self.salery)\n",
    "        \n",
    "class developer(employee):\n",
    "    \n",
    "    def calculate_salery(self):\n",
    "        print(\"developer salery is :\",self.salery)\n",
    "        \n",
    "class designer(employee):\n",
    "    \n",
    "    def calculate_salery(self):\n",
    "        print(\"designer salery is :\",self.salery)\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "c09e7e24-9c0c-4814-ad2b-aad34b2ca0fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_designer =designer(40000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "76dccabb-cd22-4db4-96f3-ca06400dc740",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "designer salery is : 40000\n"
     ]
    }
   ],
   "source": [
    "obj_designer.calculate_salery()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "44e7d77c-e710-4a5a-85e0-299d9679ef09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "developer salery is : 70000\n"
     ]
    }
   ],
   "source": [
    "obj_developer =developer(70000)\n",
    "obj_developer.calculate_salery()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "a401e0d9-ff73-4530-8068-a17c6799125f",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_manager =manager(1200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "8df0e218-42e5-4477-bc8f-e0b3a01811ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manager salery is : 1200000\n"
     ]
    }
   ],
   "source": [
    "obj_manager.calculate_salery()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b96bea68-d738-4a54-8c56-58ecebc56c75",
   "metadata": {},
   "source": [
    "18. Discuss the concept of function pointers and how they can be used to achieve polymorphism in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60b388d1-618b-490b-a761-6985cc99c410",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    olymorphism can be used to allow common behavior with different types, and to let the system choose which function to call based on type and parameter signatures. Function pointers are indicated when a common function such as a sort or a search is to be performed on different criteri"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b091818d-9674-4d72-a4a2-3dc36be6648b",
   "metadata": {},
   "source": [
    "19. Explain the role of interfaces and abstract classes in polymorphism, drawing comparisons between them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30db5aab-768a-4483-a5d2-0060ebcb7be2",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    With abstract classes, you basically define the class as abstract and the methods you want to enforce as abstract without actually putting any code inside those methods. Then you create a child class extending the parent abstract class and implement the abstract methods in that child class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b3b9bd6-c4c3-44e9-95b5-19d0d008ec9d",
   "metadata": {},
   "source": [
    "20. Create a Python class for a zoo simulation, demonstrating polymorphism with different animal types (e.g., mammals, birds, reptiles) and their behavior (e.g., eating, sleeping, making sounds)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "1911d790-2363-46d0-a882-2e64548925f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "class Animal:\n",
    "    \"\"\"Base class for all animals in the zoo simulation.\"\"\"\n",
    "\n",
    "    def __init__(self, name, animal_type):\n",
    "        self.name = name\n",
    "        self.animal_type = animal_type\n",
    "\n",
    "    def eat(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def sleep(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def make_sound(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "class Mammal(Animal):\n",
    "    \"\"\"Class for mammals in the zoo simulation.\"\"\"\n",
    "\n",
    "    def eat(self):\n",
    "        print(f\"{self.name} the mammal is eating.\")\n",
    "\n",
    "    def sleep(self):\n",
    "        print(f\"{self.name} the mammal is sleeping.\")\n",
    "\n",
    "    def make_sound(self):\n",
    "        print(f\"{self.name} the mammal is making a sound.\")\n",
    "\n",
    "class Bird(Animal):\n",
    "    \"\"\"Class for birds in the zoo simulation.\"\"\"\n",
    "\n",
    "    def eat(self):\n",
    "        print(f\"{self.name} the bird is eating.\")\n",
    "\n",
    "    def sleep(self):\n",
    "        print(f\"{self.name} the bird is sleeping.\")\n",
    "\n",
    "    def make_sound(self):\n",
    "        print(f\"{self.name} the bird is making a sound.\")\n",
    "\n",
    "class Reptile(Animal):\n",
    "    \"\"\"Class for reptiles in the zoo simulation.\"\"\"\n",
    "\n",
    "    def eat(self):\n",
    "        print(f\"{self.name} the reptile is eating.\")\n",
    "\n",
    "    def sleep(self):\n",
    "        print(f\"{self.name} the reptile is sleeping.\")\n",
    "\n",
    "    def make_sound(self):\n",
    "        print(f\"{self.name} the reptile is making a sound.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "845ca070-22b6-41e7-a907-d63f4e0fae98",
   "metadata": {},
   "outputs": [],
   "source": [
    "lion = Mammal(\"Leo\", \"Lion\")\n",
    "eagle = Bird(\"Soaring\", \"Eagle\")\n",
    "snake = Reptile(\"Slinky\", \"Snake\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "2f2c3d21-538d-4f11-bee8-b75e93635804",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Leo the mammal is making a sound.\n"
     ]
    }
   ],
   "source": [
    "lion.make_sound()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "2a045909-eaf9-411f-866c-960313771c43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Soaring the bird is making a sound.\n"
     ]
    }
   ],
   "source": [
    "eagle.make_sound()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "653612d7-35be-4e5f-b3e7-68fc3b71fda9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slinky the reptile is making a sound.\n"
     ]
    }
   ],
   "source": [
    "snake.make_sound()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "650c6228-6ece-416b-b5ed-c58b8b7ea0a9",
   "metadata": {},
   "source": [
    "### Abstraction:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e2f15a7-a6ab-42ac-8c0b-5ff86861829d",
   "metadata": {},
   "source": [
    "1. What is abstraction in Python, and how does it relate to object-oriented programming?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f5b673b-4046-4d33-98e6-75adc1627bfc",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Abstraction in python is defined as a process of handling complexity by hiding unnecessary information from the user. This is one of the core concepts of object-oriented programming (OOP) languages"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f826c18-6a7d-4f03-8d0b-253c1e2a8fbc",
   "metadata": {},
   "source": [
    "2. Describe the benefits of abstraction in terms of code organization and complexity reduction."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "789854a1-448d-413d-af59-3f517afebacb",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Abstraction is a powerful programming technique that allows us to simplify complex systems by hiding unnecessary details. It has many benefits, including:\n",
    "\n",
    "    Improved code organization: Abstraction allows us to group related code together into modules or classes, which makes the code easier to read, understand, and maintain.\n",
    "    Reduced complexity: By hiding unnecessary details, abstraction makes the code less complex and easier to reason about.\n",
    "    Increased reusability: Abstracted code can be reused in different contexts without having to modify the underlying implementation.\n",
    "    Improved maintainability: Abstracted code is easier to maintain because changes can be made to the underlying implementation without affecting the rest of the code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aff45d29-4ba3-4c1e-9a45-b1e783278d86",
   "metadata": {},
   "source": [
    "3. Create a Python class called `Shape` with an abstract method `calculate_area()`. Then, create child classes (e.g., `Circle`, `Rectangle`) that implement the "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d5050df8-aba9-4b3f-a711-4485895c8d6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC ,abstractmethod \n",
    "\n",
    "class shape :\n",
    "    \n",
    "    @abstractmethod\n",
    "    def calculate_area(self):\n",
    "        print(\"Calculate area of shape\")\n",
    "        \n",
    "class circle(shape):\n",
    "    @abstractmethod\n",
    "    def calculate_area(self ,redious):\n",
    "        return redious**2\n",
    "    \n",
    "class rectangle(shape):\n",
    "    @abstractmethod\n",
    "    def calculate_area(self ,length , width):\n",
    "        return 0.5 * length * width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7ccf3c9d-a48a-40c3-a62b-a4ebcb5835a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_rectangle = rectangle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "37d6c1f1-5736-4468-8d4a-cd8bfa01a979",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "138.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_rectangle.calculate_area(12, 23)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1cdf5d39-cebe-4e2b-aa71-e9dfca4d9ed8",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_circle  =circle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ea25e798-486b-4c93-8e21-d798811bf473",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "144"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_circle.calculate_area(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51813165-43c7-4375-bab5-3159a2db98d7",
   "metadata": {},
   "source": [
    "4. Explain the concept of abstract classes in Python and how they are defined using the `abc` module. Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "267da5d7-ce1e-43b9-9dd5-9f73f7f4c47f",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    An abstract class can be considered a blueprint for other classes. It allows you to create a set of methods that must be created within any child classes built from the abstract class. A class that contains one or more abstract methods is called an abstract class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0aad5adb-dbe2-4e2d-b475-2bea278859af",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC ,abstractmethod\n",
    "class pwskills:\n",
    "    \n",
    "    @abstractmethod\n",
    "    def databaseconnect(self):\n",
    "        pass\n",
    "    @abstractmethod\n",
    "    def checkenrollment(self ,user_mail):\n",
    "        pass\n",
    "    @abstractmethod\n",
    "    def check_completed_lecture(self ,userId ,classID):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "aafed6a4-97c7-4f7f-83cb-bc036d837ae5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class student_details(pwskills):\n",
    "    \n",
    "    def databaseconnect(self):\n",
    "        print(\"Database connection is sucess\")\n",
    "        \n",
    "    def checkenrollment(self ,user_mail):\n",
    "        return \"These user is enrolled\"\n",
    "    \n",
    "    def check_completed_lecture(self ,userID ,classID):\n",
    "        return \"thse user has completed lecture \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4bd850c0-52eb-4b96-a273-a257aeea98ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_student = student_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6db472b0-f84f-4397-a97c-5698c19bb04e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'thse user has completed lecture '"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_student.check_completed_lecture(\"chopade\",1010)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5e214152-9b1e-4dea-a57e-a5240a469a34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'These user is enrolled'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_student.checkenrollment(\"bhush@gmail.com\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "121773c0-42bf-443c-864d-e218cbe03f6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Database connection is sucess\n"
     ]
    }
   ],
   "source": [
    "obj_student.databaseconnect()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d47fe5e-81ec-482f-af1d-0fa8ed57555d",
   "metadata": {},
   "source": [
    "5. How do abstract classes differ from regular classes in Python? Discuss their use cases."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8427c6c0-6ee1-4537-94b5-686bff701a61",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    An abstract class can be considered a blueprint for other classes. It allows you to create a set of methods that must be created within any child classes built from the abstract class. A class that contains one or more abstract methods is called an abstract class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53d9010e-c33d-480d-b154-ba4df696665d",
   "metadata": {},
   "source": [
    "Usecases :\n",
    "    \n",
    "    An abstract class is mostly used to provide a base for subclasses to extend and implement the abstract methods and override or use the implemented methods in abstract class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39ae4bd0-0366-4a8b-92fe-9f6769599f1b",
   "metadata": {},
   "source": [
    "6. Create a Python class for a bank account and demonstrate abstraction by hiding the account balance and providing methods to deposit and withdraw funds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9ac113c3-20e2-484d-b76e-a492b498e7f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC ,abstractmethod\n",
    "class bankaccount :\n",
    "    \n",
    "    \n",
    "    def __init__(self ,balance):\n",
    "        self.__balance =balance\n",
    "        \n",
    "    def deposite_money(self,amount):\n",
    "        self.__balance =self.__balance + amount\n",
    "        print(\"You have deposited amount :\",amount)\n",
    "        \n",
    "    def withdraw_amount(self, withdrw_amt):\n",
    "        self.__balance =self.__balance - withdrw_amt\n",
    "        print(\"You have withdraw :\",withdrw_amt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "36adb0a7-9cc5-426c-8d0d-47302dd919d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_bank =bankaccount(50000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6f0a6f72-351d-412d-99b7-86617de39082",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have deposited amount : 2000\n"
     ]
    }
   ],
   "source": [
    "obj_bank.deposite_money(2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "86cffdc4-b9a1-4bb6-a5ca-559735dfbf9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have withdraw : 2000\n"
     ]
    }
   ],
   "source": [
    "obj_bank.withdraw_amount(2000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66a0b6dd-7175-4a92-b8b4-42c3c0a6141e",
   "metadata": {},
   "source": [
    "7. Discuss the concept of interface classes in Python and their role in achieving abstraction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53ecf691-4e90-4be8-9d5a-8baaf5a65f73",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Interface classes in Python are a way to define a set of methods that must be implemented by any class that claims to implement the interface. Interface classes are not concrete, meaning that they cannot be instantiated directly. Instead, they are used as a blueprint for other classes to follow."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e373d78-f601-4812-9a8b-7fd87dbbcaa4",
   "metadata": {},
   "source": [
    "Interface classes can help to achieve abstraction in the following ways:\n",
    "\n",
    "    They provide a common interface for different implementations of the same functionality. This makes it easier to switch between different implementations without having to modify the client code.\n",
    "    They allow us to focus on the \"what\" of an object, rather than the \"how\". This makes the code more readable and maintainable.\n",
    "    They can help to reduce coupling between different parts of the system. This makes the system more robust and less likely to fail if one part changes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "256201fa-29f5-4bf9-97cd-7fae26978e57",
   "metadata": {},
   "source": [
    "8. Create a Python class hierarchy for animals and implement abstraction by defining common methods (e.g., `eat()`, `sleep()`) in an abstract base class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "14ab52fe-57a2-4cb5-bcd2-a6aa7e10c10f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC ,abstractmethod\n",
    "class animal :\n",
    "    \n",
    "    @abstractmethod\n",
    "    def eat(self):\n",
    "        return \"thise is eat method from base class\"\n",
    "    \n",
    "    @abstractmethod\n",
    "    def sleep(self):\n",
    "        return \"thise is sleep method from base class\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8e3acaf6-b22b-42a6-846d-938117e480d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog(animal):\n",
    "    \n",
    "    def eat(self):\n",
    "        print(\"Dog will eat his food\")\n",
    "        \n",
    "    def sleep(self):\n",
    "        print(\"Dog will sleep at day\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6638a485-a255-46c8-9f8e-4f950d167e46",
   "metadata": {},
   "outputs": [],
   "source": [
    "class cat(animal):\n",
    "    \n",
    "    def eat(self):\n",
    "        print(\"Cat will eat food \")\n",
    "        \n",
    "    def sleep(self):\n",
    "        print(\"Cat will sleep at night\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0da41dab-0331-43dc-90c0-e2f9944d76f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_cat =cat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "214d2ecf-6831-4452-a24a-46c01b28b673",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cat will eat food \n"
     ]
    }
   ],
   "source": [
    "obj_cat.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5d3e3823-8ab7-43b5-ae9d-2a618531ac5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cat will sleep at night\n"
     ]
    }
   ],
   "source": [
    "obj_cat.sleep()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c9278c76-509f-4d77-b80d-de81965198e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_dog =Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e450781c-f59d-4fdb-aac7-05b8f476acff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog will eat his food\n"
     ]
    }
   ],
   "source": [
    "obj_dog.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a70a10eb-5688-489a-b6b9-72685a297343",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog will sleep at day\n"
     ]
    }
   ],
   "source": [
    "obj_dog.sleep()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b3ae1fd-3fa6-46b8-b067-e50f17d28c94",
   "metadata": {},
   "source": [
    "9. Explain the significance of encapsulation in achieving abstraction. Provide examples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4848ee5a-484c-45dd-936e-6da5af7ac4c0",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Encapsulation involves bundling data members (attributes) and methods (functions) into a single unit (class). Abstraction focuses on defining the essential methods and properties of a class without specifying their implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "11ce5376-0b69-49d3-8048-c54ecf8a9780",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BankAccount:\n",
    "    \n",
    "    def __init__(self, name, account_number, balance):\n",
    "        self._name = name\n",
    "        self._account_number = account_number\n",
    "        self.__balance = balance\n",
    "        \n",
    "        \n",
    "    def check_banlance(self):\n",
    "        return self.__balance\n",
    "    \n",
    "    def show_accountNo(self):\n",
    "        return self._account_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8dffed24-240e-42e5-972b-7ae37ce1bffe",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_bank_account =BankAccount(\"Bhushan\" ,123125687632 ,109000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "39cfda5d-a6cc-45e6-b23c-7cbb51f508ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123125687632"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_bank_account.show_accountNo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "67773ec2-7f7d-4f21-a5d8-96c7a763e8f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "109000"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_bank_account.check_banlance()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8b6f114-2859-4c0e-8d6b-bd9f4abadddc",
   "metadata": {},
   "source": [
    "10. What is the purpose of abstract methods, and how do they enforce abstraction in Python classes?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8047983d-45f5-4312-8e03-3e73d4723b84",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Abstract methods force the child classes to give the implementation of these methods in them and thus help us achieve abstraction as each subclass can give its own implementation. A class containing one or more than one abstract method is called an abstract class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d85413b-eebe-4ffd-9bb9-a6c0c8cf4873",
   "metadata": {},
   "source": [
    "11. Create a Python class for a vehicle system and demonstrate abstraction by defining common methods (e.g., `start()`, `stop()`) in an abstract base class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "222c3e2c-1cf3-40d1-9d58-e72affcac923",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC ,abstractmethod\n",
    "class vehicle :\n",
    "    \n",
    "    def __init__(self , make ,model ,year):\n",
    "        self.make =make\n",
    "        self.model =model\n",
    "        self.year =year\n",
    "        \n",
    "    @abstractmethod    \n",
    "    def start(self):\n",
    "        print(\"Thise is start method\")\n",
    "        \n",
    "    @abstractmethod    \n",
    "    def stop(self):\n",
    "        print(\"thise is stop method\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b4343612-f322-4078-afbe-bb2b69bc6a45",
   "metadata": {},
   "outputs": [],
   "source": [
    "class car(vehicle):\n",
    "    \n",
    "    def start(self):\n",
    "        print(\"starting the car\")\n",
    "        \n",
    "    def stop(self):\n",
    "        print(\"stop the car\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3ed1ad07-10e2-460e-a032-cc1e6abe87d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class truck(vehicle):\n",
    "    \n",
    "    def start(self):\n",
    "        print(\"starting the truck\")\n",
    "        \n",
    "    def stop(self):\n",
    "        print(\"Stop the truck\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "96339b90-66d4-463a-90c9-8d18224e3ac9",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_car =car(\"TATA\",\"Totyota\",2022)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "38077a24-706d-44ab-8479-f24d5b540d4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting the car\n"
     ]
    }
   ],
   "source": [
    "obj_car.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "eebda42b-f18e-4425-8e94-73dd63a79a83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stop the car\n"
     ]
    }
   ],
   "source": [
    "obj_car.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "70a74377-7f1a-45f1-aba4-b7eba37f996c",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_truck =truck(\"TATA\" ,\"Either\",2019)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c848b34f-09f2-4208-bd7d-acc5259866d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting the truck\n"
     ]
    }
   ],
   "source": [
    "obj_truck.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b4a936a1-f17e-4d4b-84c3-5db21ce129b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stop the truck\n"
     ]
    }
   ],
   "source": [
    "obj_truck.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37c94479-38d0-450e-ba5d-a39164079ba7",
   "metadata": {},
   "source": [
    "12. Describe the use of abstract properties in Python and how they can be employed in abstract classe"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "384529e5-4ead-4365-b2d9-7a631562e33c",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    The methods and properties defined (but not implemented) in an abstract class are called abstract methods and abstract properties. All abstract methods and properties need to be implemented in a child class in order to be able to create objects from it"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa436bbc-db39-453c-937b-83736cd4b3c2",
   "metadata": {},
   "source": [
    "13. Create a Python class hierarchy for employees in a company (e.g., manager, developer, designer) and implement abstraction by defining a common `get_salary()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "86ed555e-f6b0-4931-8cae-a8a1098204f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC ,abstractmethod\n",
    "class employee :\n",
    "    \n",
    "    @abstractmethod\n",
    "    def get_salery(self):\n",
    "        print(\"Got the salery \")\n",
    "        \n",
    "class manager(employee):\n",
    "    \n",
    "    def get_salery(self):\n",
    "        print(\"manager salery is credited\")\n",
    "        \n",
    "class developer(employee):\n",
    "    \n",
    "    def get_salery(self):\n",
    "        print(\"developer salery is credited\")\n",
    "        \n",
    "class designer(employee):\n",
    "    \n",
    "    def get_salery(self):\n",
    "        print(\"developer salery is credited\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "982367d8-3196-4bdc-9183-9a1bf2abf731",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "manager salery is credited\n"
     ]
    }
   ],
   "source": [
    "obj_manager =manager()\n",
    "obj_manager.get_salery()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f345d860-d141-4432-8aac-f426b54b96cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "developer salery is credited\n"
     ]
    }
   ],
   "source": [
    "obj_developer =developer()\n",
    "obj_developer.get_salery()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c2513452-923b-4c13-b0ac-c7faadadbe0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "developer salery is credited\n"
     ]
    }
   ],
   "source": [
    "obj_designer =designer()\n",
    "obj_designer.get_salery()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a958fc7-b0e4-45dd-a6f7-a974dd4958ed",
   "metadata": {},
   "source": [
    "14. Discuss the differences between abstract classes and concrete classes in Python, including their instantiation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb66620e-24ab-4ccd-940a-dac9912f5718",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Abstract classes in Python are classes that cannot be instantiated directly, but must be inherited from by concrete classes. They are used to define a blueprint for concrete classes,"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a06cc2c-6ab1-4dc8-bae1-3dee7e52fbee",
   "metadata": {},
   "source": [
    "concreate classes:\n",
    "    \n",
    "    \n",
    "    Concrete classes are classes that can be instantiated directly. They are the classes that actually implement the functionality of our program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f87daf66-cdd3-42f9-9bcd-dce58fafd36f",
   "metadata": {},
   "source": [
    "15. Explain the concept of abstract data types (ADTs) and their role in achieving abstraction in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86a210d5-1bd2-4dae-bf36-fa10ffc8c851",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    \n",
    "    Abstract data types (ADTs) are a way of encapsulating data and operations on that data into a single unit. Some of the key features of ADTs include: Abstraction: The user does not need to know the implementation of the data structure only essentials are provided."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdecb04b-6c2a-4135-8879-bbe9541379a1",
   "metadata": {},
   "source": [
    "16. Create a Python class for a computer system, demonstrating abstraction by defining common methods (e.g., `power_on()`, `shutdown()`) in an abstract base class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7432bcd2-d8f1-44fe-a85b-9df9eb1361e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC ,abstractmethod\n",
    "class computer_sytem :\n",
    "    \n",
    "    @abstractmethod\n",
    "    def power_on(self):\n",
    "        print(\"Power on the system\")\n",
    "    \n",
    "    @abstractmethod\n",
    "    def shutdown(self):\n",
    "        print(\"shutdown the system\")\n",
    "        \n",
    "        \n",
    "class desktop_computer(computer_sytem):\n",
    "    \n",
    "    def power_on(self):\n",
    "        print(\"power on desktop\")\n",
    "        \n",
    "    def shutdown(self):\n",
    "        print(\"shut down the desktop\")\n",
    "        \n",
    "        \n",
    "class laptop(computer_sytem):\n",
    "    \n",
    "    def power_on(self):\n",
    "        print(\"power on the laptop\")\n",
    "        \n",
    "    def shutdown(self):\n",
    "        print(\"shut the the laptop\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4e89cf09-beba-4a8c-99bb-cf279c52424b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "power on the laptop\n"
     ]
    }
   ],
   "source": [
    "obj_laptop =laptop()\n",
    "obj_laptop.power_on()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d933c261-64e0-4d0a-a8f8-b150be06cd23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shut the the laptop\n"
     ]
    }
   ],
   "source": [
    "obj_laptop.shutdown()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9d666bd3-7a8b-4e7a-bdcb-ad6b6712449e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "power on desktop\n"
     ]
    }
   ],
   "source": [
    "obj_desktop =desktop_computer()\n",
    "obj_desktop.power_on()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "21c3d480-7558-4775-a3a3-b8d8a96b0023",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shut down the desktop\n"
     ]
    }
   ],
   "source": [
    "obj_desktop.shutdown()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b3e4e38-6693-44bb-bb80-72447942364d",
   "metadata": {},
   "source": [
    "17. Discuss the benefits of using abstraction in large-scale software development projects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20bf1898-41e5-40d9-ad30-00000f57dbda",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Data abstraction may reduce the effort required to make changes and updates to the code by isolating the implementation details of a data structure. There is less chance of errors or other problems when making changes to the implementation of the data structure rather than the code that utilises it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d7420ba-ec3f-4d06-816a-537b012c349f",
   "metadata": {},
   "source": [
    "18. Explain how abstraction enhances code reusability and modularity in Python programs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4465b21e-d999-4d79-9512-6f56ca64535c",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Abstraction focuses on bundling data and methods within an object to improve control and modularity. Abstraction simplifies complex systems by breaking them into smaller components, improving maintainability, debugging, testing, collaboration, and integration of new features."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57c96ded-7704-4e46-b860-308ab94a7327",
   "metadata": {},
   "source": [
    "19. Create a Python class for a library system, implementing abstraction by defining common methods (e.g., `add_book()`, `borrow_book()`) in an abstract base class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "337894dd-23a4-4412-84c4-31d88c7b77d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC ,abstractmethod\n",
    "class libery_sytem:\n",
    "    \n",
    "    @abstractmethod\n",
    "    def add_book(self):\n",
    "        pass\n",
    "    \n",
    "    @abstractmethod\n",
    "    def borrow_book(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b916b780-8233-4d1b-b4a2-6440223a1c08",
   "metadata": {},
   "outputs": [],
   "source": [
    "class libery(libery_sytem):\n",
    "    \n",
    "    def add_book(self ,libery_add_book):\n",
    "        print(\"book is added in libery :\",libery_add_book)\n",
    "        \n",
    "    def borrow_book(self):\n",
    "        print(\"book is borrow from libery\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "81d69d87-5495-4d7a-86a3-ca614a0cf2d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_libery =libery()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "f30c6ae3-9dde-414b-b80a-3c8625e223d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "book is added in libery : Python\n"
     ]
    }
   ],
   "source": [
    "obj_libery.add_book(\"Python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "f73f192a-fa84-4729-894d-f804412b9758",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "book is borrow from libery\n"
     ]
    }
   ],
   "source": [
    "obj_libery.borrow_book()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecbf6b98-f05e-43ec-839e-f39a6e9f3d7b",
   "metadata": {},
   "source": [
    "20. Describe the concept of method abstraction in Python and how it relates to polymorphism."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ba794f9-185e-46e8-98c3-2e8ab853fd8d",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    \n",
    "    Method abstraction in Python is the process of hiding the implementation details of a method from the user. This allows the user to focus on what the method does, rather than how it does it. Method abstraction can be achieved by using private methods and public methods. Private methods are only accessible within the class in which they are defined, while public methods are accessible to other classes.`\n",
    "    \n",
    "    Polymorphism in Python is the ability of objects of different types to respond to the same method call in different ways. This is achieved by using inheritance and overriding. Inheritance allows a class to inherit the methods and attributes of another class. Overriding allows a class to redefine a method that it has inherited from a parent class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed402952-2081-49dc-874e-a08151d93b28",
   "metadata": {},
   "source": [
    "relations :\n",
    "    \n",
    "    \n",
    "\n",
    "    Method abstraction and polymorphism are related in that they both allow us to write more flexible and reusable code. By abstracting away the implementation details of methods, we can make our code easier to understand and maintain. By using polymorphism, we can write code that is more generic and can be used with different types of objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a537bba-9e78-4a15-98e7-5624a72d1f90",
   "metadata": {},
   "source": [
    "### Composition"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f6c43f5-758a-4e68-a457-44632b11a08a",
   "metadata": {},
   "source": [
    "1. Explain the concept of composition in Python and how it is used to build complex objects from simpler ones."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53309610-d7e8-4e4d-bf03-9410ff339d80",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Composition is a concept that models a has a relationship. It enables creating complex types by combining objects of other types. This means that a class Composite can contain an object of another class Component . This relationship means that a Composite has a Component "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57ad8254-fe10-4f5f-ada0-dc94be51df6f",
   "metadata": {},
   "source": [
    "2. Describe the difference between composition and inheritance in object-oriented programming."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3b0847b-3b23-4b42-ae42-cc7296a9c92a",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    \n",
    "    In inheritance, the child class is dependent upon parent class. \n",
    "    \n",
    "    \n",
    "    Whereas in composition, both child class and parent class are independent"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f487ad66-71a6-46f8-8244-d6a800881d6c",
   "metadata": {},
   "source": [
    "3. Create a Python class called `Author` with attributes for name and birthdate. Then, create a `Book` class that contains an instance of `Author` as a composition. Provide an example of creating a `Book` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c4d80645-56cc-4f59-8446-cf403ad6ada0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Author :\n",
    "    \n",
    "    def __init__(self ,name ,birthdate):\n",
    "        self.name =name \n",
    "        self.birthdate =birthdate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "7ca78682-0a27-4964-93c2-91c7fa7adaa2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Book :\n",
    "    \n",
    "    def __init__(self,obj_Author):\n",
    "        self.obj_Author =obj_Author\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2f18cc32-69d6-4bc4-8d71-3cc687f24a96",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_Author =Author(\"Bhushan\",\"326676\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3730e03f-4c02-4a58-b023-d18252f74010",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_book =Book(obj_Author)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b3fc0f02-5962-4c18-bf7f-f110d8f9d1ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'326676'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_book.obj_Author.birthdate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "34a6c7f5-5a02-4326-8201-d07dfeffd71d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bhushan'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_book.obj_Author.name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de8efa49-8a49-49c0-b236-2395efe34be1",
   "metadata": {},
   "source": [
    "4. Discuss the benefits of using composition over inheritance in Python, especially in terms of code flexibility and reusability"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a465870-4026-4fcf-a11a-3db05434fd34",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Composition enables you to reuse code by adding objects to other objects, as opposed to inheriting the interface and implementation of other classes. Both Horse and Dog classes can leverage the functionality of Tail through composition without deriving one class from the other"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c30bb81b-0f99-4ed6-ac74-2adb7a8f9099",
   "metadata": {},
   "source": [
    "5. How can you implement composition in Python classes? Provide examples of using composition to create complex objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1685b444-f982-4838-a7a2-a952fc991b76",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Through the compositions, we actually state the relationship between the two classes. And in this way, the code can be reused. This has a common similarity with the concept of inheritance. As a result, we obtain more complex structures by combining objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2c3f043e-4ef2-4d56-8070-eedf3f3d764d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Example \n",
    "class pwskills :\n",
    "    \n",
    "    def datascience(self):\n",
    "        print(\"thise is data science class\")\n",
    "        \n",
    "class web_dev :\n",
    "    def __init__(self ,syllabus ,mentor):\n",
    "        self.syllabus =syllabus\n",
    "        self.mentor =pwskills()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "4bac3394-674b-4f1f-be23-c220b6b77a04",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_web =web_dev(\"Python\" ,\"sudhanshu kumar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "81ef2cee-e713-43a4-8ca0-cba34541a925",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "thise is data science class\n"
     ]
    }
   ],
   "source": [
    "obj_web.mentor.datascience()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "27f4177d-92fe-45e2-a0d8-cf14c2840ea7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_web.syllabus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8e7ea32-78ef-4c61-bf45-7bba746f160b",
   "metadata": {},
   "source": [
    "6. Create a Python class hierarchy for a music player system, using composition to represent playlists and songs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "fbf18948-47dc-4cef-b008-d556d5444bc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Playing song: Bohemian Rhapsody by Queen\n",
      "Playing song: Imagine by John Lennon\n",
      "Playing song: Hey Jude by The Beatles\n",
      "Playing song: Hey Jude by The Beatles\n"
     ]
    }
   ],
   "source": [
    "class Song:\n",
    "\n",
    "    \n",
    "    def __init__(self, title, artist, album, length):\n",
    "        self.title = title\n",
    "        self.artist = artist\n",
    "        self.album = album\n",
    "        self.length = length\n",
    "\n",
    "    def play(self):\n",
    "        print(f\"Playing song: {self.title} by {self.artist}\")\n",
    "\n",
    "class Playlist:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.songs = []\n",
    "\n",
    "    def add_song(self, song):\n",
    "        self.songs.append(song)\n",
    "\n",
    "    def play(self):\n",
    "        for song in self.songs:\n",
    "            song.play()\n",
    "\n",
    "class MusicPlayer:\n",
    "    def __init__(self):\n",
    "        self.current_playlist = None\n",
    "\n",
    "    def play_playlist(self, playlist):\n",
    "        self.current_playlist = playlist\n",
    "        playlist.play()\n",
    "\n",
    "    def play_song(self, song):\n",
    "        song.play()\n",
    "\n",
    "# Example usage:\n",
    "\n",
    "song1 = Song(\"Bohemian Rhapsody\", \"Queen\", \"A Night at the Opera\", \"5:55\")\n",
    "song2 = Song(\"Imagine\", \"John Lennon\", \"Imagine\", \"3:10\")\n",
    "song3 = Song(\"Hey Jude\", \"The Beatles\", \"Hey Jude\", \"7:11\")\n",
    "\n",
    "playlist1 = Playlist(\"My Favorite Songs\")\n",
    "playlist1.add_song(song1)\n",
    "playlist1.add_song(song2)\n",
    "playlist1.add_song(song3)\n",
    "\n",
    "music_player = MusicPlayer()\n",
    "\n",
    "# Play the playlist\n",
    "music_player.play_playlist(playlist1)\n",
    "\n",
    "# Play a specific song\n",
    "music_player.play_song(song3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cbb4276-4b0b-4995-acee-56375ca1308b",
   "metadata": {},
   "source": [
    "7. Explain the concept of \"has-a\" relationships in composition and how it helps design software systems"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c103b95a-49c9-4fb7-b699-e4db715cb2cd",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    It is one of the fundamental concepts of Object-Oriented Programming. In this concept, we will describe a class that references to one or more objects of other classes as an Instance variable. Here, by using the class name or by creating the object we can access the members of one class inside another class. It enables creating complex types by combining objects of different classes. It means that a class Composite can contain an object of another class Component. This type of relationship is known as Has-A Relation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a200c7c-7748-4533-82fd-ef9f7600adaf",
   "metadata": {},
   "source": [
    "8. Create a Python class for a computer system, using composition to represent components like CPU, RAM, and storage devices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "0c6b23e9-e580-409c-addd-e7572e4f8257",
   "metadata": {},
   "outputs": [],
   "source": [
    "class computer_system :\n",
    "    \n",
    "    def __init__(self ,cpu ,ram ,storage_device):\n",
    "        self.cpu =cpu\n",
    "        self.ram =ram \n",
    "        self.storage_device =storage_device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "70d60950-8823-42e9-87f1-2a50c9992bd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CPU :\n",
    "    \n",
    "    def __init__(self ,name ,speed):\n",
    "        self.name = name\n",
    "        self.speed =speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "892cd569-abe3-46e2-ac7c-942044ddb21b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class RAM :\n",
    "    \n",
    "    def __init__(self ,size ,speed):\n",
    "        self.size =size\n",
    "        self.speed =speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "701aa7ab-85f8-4950-b048-b0443d4c56dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class STORAGE_DEVICE :\n",
    "    \n",
    "    def __init__(self ,st_type ,size ,speed):\n",
    "        self.st_type =st_type\n",
    "        self.size =size\n",
    "        self.speed =speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "87b977b1-c4ed-4baf-b62f-b9609994e346",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_cpu =CPU(\"Intel I5\",\"2.4GHZ\")\n",
    "obj_ram =RAM(\"8GB\",1200)\n",
    "obj_storage_device =STORAGE_DEVICE(\"SSD\", \"1TB\",1500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "96274483-2f49-482c-9bc1-f380785222c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "computer_sytem =computer_system(obj_cpu ,obj_ram ,obj_storage_device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "74301990-4c20-462b-bce6-9ac3c686af15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.4GHZ'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_sytem.cpu.speed"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a80e032-39ef-4623-9ae2-7069adf158c0",
   "metadata": {},
   "source": [
    "9. Describe the concept of \"delegation\" in composition and how it simplifies the design of complex systems"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ad6acd7-c882-45d4-8467-f18f81ed2dc1",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Object Delegation means using the object of another class as a class member of another class. It is known as object delegation. Delegation can be an alternative to inheritance, but in an inheritance, there is an i-s a relationship, but in the delegation, there is no inheritance relationship between the classes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3a7e4b4-6fc7-4276-a87d-2a0c8710f6f5",
   "metadata": {},
   "source": [
    "10. Create a Python class for a car, using composition to represent components like the engine, wheels, and transmission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "8ec5c3ca-d22e-4909-b0b3-1bf0f38fa13f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class car :\n",
    "    \n",
    "    def __init__(self ,engine ,wheels ,transmission):\n",
    "        self.engine =engine \n",
    "        self.wheels =wheels\n",
    "        self.transmission =transmission\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "c45cda43-1d45-460e-98fc-bc6d0131f401",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Engine :\n",
    "    \n",
    "    def __init__(self ,Engine_CC):\n",
    "        self.Engine_CC =Engine_CC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "be24c9bc-277b-42b7-ba5f-40f9e49d31a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class wheels :\n",
    "    \n",
    "    def __init__(self ,no_of_wheel):\n",
    "        self.no_of_wheel =no_of_wheel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "febb21a3-fee7-45d4-b5ce-b9591b943f49",
   "metadata": {},
   "outputs": [],
   "source": [
    "class transmission :\n",
    "    \n",
    "    def __init__(self ,type_of_transmission):\n",
    "        self.type_of_transmission =type_of_transmission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "05b586a6-cd52-4d0c-92c2-ed12455de1ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_engine =Engine(350)\n",
    "obj_wheels =wheels(4)\n",
    "obj_transmission =transmission(\"Air cooled\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "8a44b0b3-4a20-4f18-8e25-edf9cf4fbde9",
   "metadata": {},
   "outputs": [],
   "source": [
    "car_system =car(obj_engine ,obj_wheels ,obj_transmission)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "c2ca6d7f-bc6f-4b8f-81e7-6f9f7ccb1d80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "350"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_system.engine.Engine_CC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "cf4dfe48-7790-4639-8715-5a7dfc192539",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Air cooled'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_system.transmission.type_of_transmission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "f2da1633-9ef7-4642-b72a-a5b674fd3108",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_system.wheels.no_of_wheel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8aca9f1e-0cd9-4b78-8d44-b43b7abc8f80",
   "metadata": {},
   "source": [
    "11. How can you encapsulate and hide the details of composed objects in Python classes to maintain abstraction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcd78d5a-7a16-47e5-a6e0-088df9af0f69",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Encapsulation: combining all the attributes and the methods that the class needs under one umbrella (class itself) makes your code easy to maintain. Abstraction: hiding away the implementation details from the external user which makes your code easy to be shared with other developers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf788264-7993-45a8-bd3f-ed9bfbf0c0dc",
   "metadata": {},
   "source": [
    "12. Create a Python class for a university course, using composition to represent students, instructors, and course materials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "7023ad7e-9287-4049-a510-1cfa269d3238",
   "metadata": {},
   "outputs": [],
   "source": [
    "class university :\n",
    "    \n",
    "    def __init__(self ,student ,instructors, course_material):\n",
    "        self.student =student\n",
    "        self.instructors =instructors\n",
    "        self.course =course_material"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "a5b59029-1808-4840-b128-910dffb1bfa0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student :\n",
    "    \n",
    "    def student_details(self):\n",
    "        return \"thise is student details\"\n",
    "    \n",
    "class Instructor :\n",
    "    \n",
    "    def instructor_class(self):\n",
    "        return \"instructor will give instruction\"\n",
    "\n",
    "class course_material():\n",
    "    \n",
    "    def matreail(self):\n",
    "        return \"Available course material\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "b3d2bcb4-04f0-457f-a675-3ea3de72ed7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_student =Student()\n",
    "obj_instructor =Instructor()\n",
    "obj_course =course_material()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "c9d98c41-a89a-47e9-8dbb-63ef2c9db707",
   "metadata": {},
   "outputs": [],
   "source": [
    "university_system =university(obj_student ,obj_instructor ,obj_course)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "42d7d40c-5704-412e-98e2-a9dcf4e449cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Available course material'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "university_system.course.matreail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "a0c7a5d3-aa4a-42b7-95e0-66a2cdcdd07e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'instructor will give instruction'"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "university_system.instructors.instructor_class()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "e25f4c58-d8d4-482d-a49c-d7513d550c5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'thise is student details'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "university_system.student.student_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "342c2e20-24c4-47f0-85c2-f7446eb3318f",
   "metadata": {},
   "source": [
    "13. Discuss the challenges and drawbacks of composition, such as increased complexity and potential for tight coupling between objects"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "727c5a32-1a73-4310-830b-c99c7df7db05",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Strategies for mitigating the challenges and drawbacks of composition\n",
    "\n",
    "There are a number of strategies that can be used to mitigate the challenges and drawbacks of composition. These include:\n",
    "\n",
    "Use abstraction and encapsulation: Abstraction and encapsulation can be used to hide the internal details of objects and make them easier to understand and use.\n",
    "Use dependency injection: Dependency injection is a technique that can be used to reduce tight coupling between objects. It involves passing dependencies between objects at runtime, rather than hard-coding them.\n",
    "Use design patterns: There are a number of design patterns that can be used to implement composition in a way that reduces complexity and tight coupling. For example, the Facade pattern can be used to provide a single interface to a complex system of interacting objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5dba79f-e497-44e6-bb00-700ee2a56d97",
   "metadata": {},
   "source": [
    "14. Create a Python class hierarchy for a restaurant system, using composition to represent menus, dishes, and ingredients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f61b2530-8ed6-4a4e-a5f4-e46f5047492a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class restaurant_system :\n",
    "    \n",
    "    def __init__(self ,menus ,dishes ,ingredients):\n",
    "        self.menus =menus\n",
    "        self.dishes =dishes\n",
    "        self.ingredients =ingredients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8939e926-1559-4273-8ffa-f00854061fde",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Menus :\n",
    "    \n",
    "    def __init__(self , thali):\n",
    "        self.thali =thali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f7fc278d-737d-48dc-b74e-45aeb052db5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dishes :\n",
    "    \n",
    "    def __init__(self ,special_dish):\n",
    "        self.special_dish =special_dish"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "727e2861-63c3-4d25-9ac9-a26d93a249f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ingredients :\n",
    "    \n",
    "    def __init__(self ,drinks):\n",
    "        self.drinks =drinks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a773549e-63a8-4cfe-ac8a-33ee4040cd44",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_menus =Menus(\"Veg thali\")\n",
    "obj_dish =Dishes(\"Paneer dish\")\n",
    "obj_ingredient = Ingredients(\"cold drink\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3b3e57b8-b420-4792-89e5-0715926727d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "Resto =restaurant_system(obj_menus ,obj_dish ,obj_ingredient)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "84f49502-52fe-4ec7-b5fe-169466ae7bbc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Paneer dish'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Resto.dishes.special_dish"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f4082105-bab7-4172-86d3-16accf3e6665",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cold drink'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Resto.ingredients.drinks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "820e95cd-5f2d-4502-8408-ed595ecb98c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Veg thali'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Resto.menus.thali"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4e1e7d5-e624-44bb-951e-59eec7e9dbfc",
   "metadata": {},
   "source": [
    "15. Explain how composition enhances code maintainability and modularity in Python programs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612756d6-4b67-4310-a13b-12a05e21d74c",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    \n",
    "    Composition is a software design principle that involves building complex objects by combining simpler objects. It is a powerful technique that can be used to enhance the maintainability and modularity of Python programs.\n",
    "\n",
    "Maintainability\n",
    "\n",
    "Composition makes code more maintainable because it allows developers to isolate changes and prevent them from cascading through the codebase. When code is composed of smaller, independent objects, it is easier to understand and troubleshoot. For example, if a developer needs to change the behavior of a particular object, they can do so without affecting the other objects in the system.\n",
    "\n",
    "Modularity\n",
    "\n",
    "Composition also promotes modularity, which is the practice of breaking down a system into smaller, self-contained modules. Modular code is easier to develop, test, and maintain. With composition, developers can create reusable modules that can be combined to create more complex functionality. For example, a developer could create a module for sending emails and then reuse that module in different parts of the system."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f98ebae0-65a5-42a9-a7d3-c595f0202527",
   "metadata": {},
   "source": [
    "16. Create a Python class for a computer game character, using composition to represent attributes like weapons, armor, and inventory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "b9497589-0714-45c0-8223-7aab6d712d7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class game_charactor :\n",
    "    \n",
    "    def __init__(self ,weapons ,armour ,inventery):\n",
    "        \n",
    "        self.weapons =weapons\n",
    "        self.armour =armour\n",
    "        self.inventery =inventery"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "033b9bb6-e393-4960-92d9-4be7fd48218a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Weapons :\n",
    "    \n",
    "    def __init__(self , weapons_use):\n",
    "        self.weapons_use =weapons_use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "01cf45a1-a8f1-47ed-a3d5-45db05e9805e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Armour :\n",
    "    \n",
    "    def __init__(self,armour_use):\n",
    "        self.armour_use =armour_use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "62b5a82c-5b6f-4d46-be7b-99ff488603d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Inventery :\n",
    "    \n",
    "    def __init__(self ,inventery_used):\n",
    "        self.inventery_used =inventery_used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "59678b84-23b9-4e84-8860-a8de0c3daa81",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_weapons =Weapons(\"Gun\")\n",
    "obj_armours =Armour(\"Swords\")\n",
    "obj_inventery =Inventery(\"Health kit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "6aff6381-47c6-4d01-a169-483b6e6c9293",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_game_char  =game_charactor(obj_weapons,obj_armours,obj_inventery)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "ed42e9de-5687-420a-9107-c16b39d058ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Swords'"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_game_char.armour.armour_use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "d8870e69-690d-4bda-b232-a75fe81a79b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Health kit'"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_game_char.inventery.inventery_used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "cefe51f3-0a93-4a2f-ad66-788e8f258b53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Gun'"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_game_char.weapons.weapons_use"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94394399-b9e4-4a41-8e2d-00ade3e30681",
   "metadata": {},
   "source": [
    "17. Describe the concept of \"aggregation\" in composition and how it differs from simple composition"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a23894a5-1a8c-4712-9e7c-fe084370238b",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Differences between aggregation and composition:\n",
    "\n",
    "In aggregation, the child class can exist independently of the parent class. In composition, the child class cannot exist independently of the parent class.\n",
    "When the parent class is destroyed, all of its child objects are destroyed in composition. In aggregation, this is not necessarily the case.\n",
    "Aggregation is a weaker type of association than composition."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "288cbf76-fbec-41fb-a5d4-ff4041f80d4b",
   "metadata": {},
   "source": [
    "18. Create a Python class for a house, using composition to represent rooms, furniture, and appliances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "a89a7f56-79bf-4b86-8f7d-05e48f959b57",
   "metadata": {},
   "outputs": [],
   "source": [
    "class house :\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.room =Room()\n",
    "        self.furniture = Furniture()\n",
    "        self.appliance =Appliance()\n",
    "        \n",
    "class Room :\n",
    "    \n",
    "    def rooms_deco(self):\n",
    "        print(\"thise is room class\")\n",
    "        \n",
    "class Furniture :\n",
    "    \n",
    "    def furniture_deco(self):\n",
    "        print(\"furniture is available in room\")\n",
    "\n",
    "class Appliance :\n",
    "    \n",
    "    def appliances_deco(self):\n",
    "        print(\"Appliance is in room\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "c0bbdd30-d929-4038-8383-25d37457a785",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_house =house()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "4e7be123-0ad0-455f-9580-ba0184226160",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Appliance is in room\n"
     ]
    }
   ],
   "source": [
    "obj_house.appliance.appliances_deco()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "4c5c198e-8950-4cc0-b517-72bf81c98159",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "furniture is available in room\n"
     ]
    }
   ],
   "source": [
    "obj_house.furniture.furniture_deco()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "16f2c1bf-381a-414a-9d43-29f36c2dac66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "thise is room class\n"
     ]
    }
   ],
   "source": [
    "obj_house.room.rooms_deco()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ff7d7b6-4732-4477-9a60-acbd1270d15e",
   "metadata": {},
   "source": [
    "19. How can you achieve flexibility in composed objects by allowing them to be replaced or modified dynamically at runtime?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4774df00-17cf-4afc-beb2-3c37374c5818",
   "metadata": {},
   "source": [
    "Ans :\n",
    "    \n",
    "    Use interfaces and abstract classes. Interfaces and abstract classes define the contracts that composed objects must fulfill. This allows you to swap out concrete implementations of composed objects without having to change the code that uses them.\n",
    "    Use dependency injection. Dependency injection is a design pattern that allows you to pass dependencies to objects at runtime. This makes it easy to replace or modify composed objects at runtime.\n",
    "    Use reflection. Reflection allows you to inspect and modify the structure of objects at runtime. This can be useful for replacing or modifying composed objects in a dynamic way."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10436af9-987e-4beb-9306-6d386f4f7ede",
   "metadata": {},
   "source": [
    "20. Create a Python class for a social media application, using composition to represent users, posts, and comments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "998b4364-4fa9-4fb2-b28c-55c49020f7f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class social_media :\n",
    "    \n",
    "    def __init__(self ,user ,post ,comments):\n",
    "        self.user =user\n",
    "        self.post =post\n",
    "        self.comments =comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c2aea141-1ef9-48ed-a3fe-d620a95b648e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class User :\n",
    "    \n",
    "    def __init__(self ,no_of_user):\n",
    "        self.no_of_user =no_of_user\n",
    "        \n",
    "class Post :\n",
    "    \n",
    "    def __init__(self ,no_of_post):\n",
    "        self.no_of_post =no_of_post\n",
    "        \n",
    "class Comments :\n",
    "    \n",
    "    def __init__(self ,no_of_comment):\n",
    "        self.no_of_comment =no_of_comment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ef96b263-13ca-4b84-8a37-68eae63f8e51",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_user =User(1000)\n",
    "obj_post =Post(2324)\n",
    "obj_comments =Comments(5000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3225ab78-974f-497b-9764-6f45d0417e1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_social_media =social_media(obj_user ,obj_post ,obj_comments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6441d26b-bdd6-4bb5-89d8-233ff8397ef5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_social_media.comments.no_of_comment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "18d817aa-4606-4632-ad4c-ebea2f202ebe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2324"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_social_media.post.no_of_post"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3a383b71-20af-4efd-aacf-75b8d6aa421f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_social_media.user.no_of_user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0231ae9b-7c1a-43f6-b4ce-6faf62297714",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}