5_Feb_oopsAssignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "23dc6c52-a679-4de9-835c-a658f636e3a5",
   "metadata": {},
   "source": [
    "### Q1. Explain Class and Object with respect to Object-Oriented Programming. Give a suitable example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c21699e-46e1-4b92-a7e1-2ef6b51388b6",
   "metadata": {},
   "source": [
    "### Class:-"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6df31d3-3111-4813-bdf0-9ce378c8070c",
   "metadata": {},
   "source": [
    "class is the blue print of a sturcture which is defined by us.\n",
    "class is basically declared by the help of class keyword.\n",
    "with the help of class we can create multiple object.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "358641d1-c5c2-4a9c-9c7f-775e5d906fb6",
   "metadata": {},
   "source": [
    "### Need of class:-"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5943c8f-1426-4683-88da-4afe43089bd4",
   "metadata": {},
   "source": [
    "for example we have to store the details of students (like-name,id,roll) and we have 100 student.storing the details for all will be very \n",
    "difficult. to solve this problem we use class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6755ce9f-a4d0-4a65-9928-59d5b55f4bf2",
   "metadata": {},
   "source": [
    "### Object:-"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03351496-2f36-4c06-a0e1-33a70eec536f",
   "metadata": {},
   "source": [
    " let's say we have created class now we have to access the data stored in that class.so for accessing the data we use to create object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "610a1b92-5599-4460-ac31-fa1446cd9d88",
   "metadata": {},
   "source": [
    "### Example:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e0165535-68de-4bb0-830c-008cd325da7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class student:  #This is class name\n",
    "    def __init__(self,name,id,roll):\n",
    "        self.name=name;\n",
    "        self.id=id;\n",
    "        self.roll=roll;           # class defination\n",
    "        \n",
    "    def student_detail(self):\n",
    "        return (self.name,self.id,self.roll)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53771f3d-ea80-4608-9d8d-8df7edf3e19e",
   "metadata": {},
   "outputs": [],
   "source": [
    "mithalesh=student(\"Mithalesh\",7853,26)    # 1st Object creation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "38faac49-43ab-45eb-9fb3-d122b0299b84",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Mithalesh', 7853, 26)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mithalesh.student_detail()      # function calling of class with the help of object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "57f72443-cece-43dc-a1f7-30479cb79b90",
   "metadata": {},
   "outputs": [],
   "source": [
    "manish=student(\"Manish\",7915,13)    # 2nd Object creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "08ad1e98-180a-495d-9a1c-30e9719b960e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Manish', 7915, 13)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "manish.student_detail()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99d7b242-fade-4727-b389-b370bee7c441",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### Q2. Name the four pillars of OOPs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4804ebf8-cf32-41d6-abf8-5586fbb4b293",
   "metadata": {},
   "source": [
    "The four pillors of OOPs is named as following."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ab432e3-e22f-4278-a68b-33d3f62f948c",
   "metadata": {},
   "source": [
    "1. Polymorphism\n",
    "2. Abstraction\n",
    "3. Inheritance\n",
    "4. Encapsulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55d1ec61-e782-416a-a222-33c1f153b346",
   "metadata": {},
   "outputs": [],
   "source": [
    "The Four pillars of OOPs, abstraction, encapsulation, inheritance, and polymorphism, are integral to understanding and using OO"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de22f02b-4f03-444e-a493-bb2c39960f41",
   "metadata": {},
   "source": [
    "### Q3. Explain why the __init__() function is used. Give a suitable example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2333a496-b34d-407d-8181-15460c17007f",
   "metadata": {},
   "source": [
    "### __init__() :-"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d6f14ab4-ab21-4271-a41a-eb9ce21acd90",
   "metadata": {},
   "source": [
    "--> In the python we use init() function as constructure.\n",
    "--> when we create object then this method execute automatically without diong forcefully.\n",
    "--> in this one parameter is compulsory.\n",
    "--> the standured parameter is self."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca29d356-10f8-48ed-9a93-1e69f986ec65",
   "metadata": {},
   "source": [
    "### Example :- "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "caaba816-18bf-4538-895d-711f7ba7e67d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class college:   # College class creation\n",
    "    def __init__(self,bca,bba,bbm):    # Use of __init__ method\n",
    "        self.bca=bca;\n",
    "        self.bba=bba;\n",
    "        self.bbm=bbm;\n",
    "    def total_student_detail(self):\n",
    "        return self.bca,self.bba,self.bbm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "69cad645-3b74-40c2-bde3-da555b87570b",
   "metadata": {},
   "outputs": [],
   "source": [
    "college1=college(45,67,89)\n",
    "college2=college(100,167,809)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "962abcc5-946e-43c7-9060-1b24491f1d51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(45, 67, 89)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "college1.total_student_detail()     # First object calling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d5ec4cf2-d462-48f4-9b80-cda9a23a4c24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 167, 809)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "college2.total_student_detail()    # Second object calling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaad9144-d280-48c4-bee5-d79ac28c862d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "13c473db-01eb-4c90-8a78-51457536830a",
   "metadata": {},
   "source": [
    "### Q4. Why self is used in OOPs?"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9380b5bb-a14f-4ee5-8e02-385685ff2e1a",
   "metadata": {},
   "source": [
    "--> self represents the instance of the class.\n",
    "--> By using the “self”  we can access the attributes and methods of the class in python. \n",
    "--> It binds the attributes with the given arguments.\n",
    "--> The reason you need to use self. is because Python does not use the @ syntax to refer to instance attributes.\n",
    "--> Python decided to do methods in a way that makes the instance to which he method belongs be passed automatically, \n",
    "but not received automatically: the first parameter of methods is the instance the method is called on."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b3c6e0f-1da2-4fe4-8ac9-2eb4ddab269a",
   "metadata": {},
   "source": [
    "Example:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "438ffd1e-409e-4e98-899d-5b6998bb9d86",
   "metadata": {},
   "outputs": [],
   "source": [
    "class address:\n",
    "    def __init__(self):\n",
    "        print(\"Address of self is =\",id(self))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d52d1052-1647-4f9a-a687-36dfff529f81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Address of self is = 140024257354272\n"
     ]
    }
   ],
   "source": [
    "a=address()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40386e83-c5ed-4b25-b777-2d61272d9846",
   "metadata": {},
   "source": [
    "### Q5. What is inheritance? Give an example for each type of inheritance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6df2ba15-6e5f-4219-9cb4-b671c7ab6f5c",
   "metadata": {},
   "source": [
    "Inheritance:-"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d2f3cda9-4c88-4a35-8dcb-2a34791a32cd",
   "metadata": {},
   "source": [
    "--> it is one of the measure concept of oops programming.\n",
    "--> it allow us to create hierarchy of classes.\n",
    "--> here is the concept of parent and child.\n",
    "--> in this the class which is going to be inherited called parent classs and the class in which\n",
    "it is inheriting called child class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "860184e8-2d3c-4f7e-b549-2d0ce53d7d0b",
   "metadata": {},
   "source": [
    "Types of inheritance:-"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09de568f-a8bb-41cb-98d2-f25ae2b723ce",
   "metadata": {},
   "source": [
    "(i) single level inheritance:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cdf50209-cd30-4ba8-ac0d-dde9d4e8ee61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function is in parent class.\n",
      "This function is in child class.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "class Parent:\n",
    "\tdef func1(self):\n",
    "\t\tprint(\"This function is in parent class.\")\n",
    "\n",
    "\n",
    "\n",
    "class Child(Parent):\n",
    "\tdef func2(self):\n",
    "\t\tprint(\"This function is in child class.\")\n",
    "        \n",
    "        \n",
    "object = Child()\n",
    "object.func1()\n",
    "object.func2()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aeebabcb-b7f4-4417-a76f-ee7ba96e8538",
   "metadata": {},
   "source": [
    "(ii) Multilevel inheritance:-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "03f6d0bc-e9a5-4a9c-b7ed-f71b981aff2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is first class's function\n",
      "This is second class's function\n",
      "this is third class's function\n"
     ]
    }
   ],
   "source": [
    "class class1:\n",
    "    def function1(self):\n",
    "        print(\"This is first class's function\")\n",
    "\n",
    "class class2(class1):  # Class1 is inheriting here.\n",
    "    def function2(self):\n",
    "        print(\"This is second class's function\")\n",
    "\n",
    "class class3(class2):    # Class2 is inheriting here.\n",
    "    def function3(self):\n",
    "        print(\"this is third class's function\")\n",
    "\n",
    "obj=class3()      # we are able to access all the class through a single class \n",
    "obj.function1()\n",
    "obj.function2()\n",
    "obj.function3()\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c650c84-31f5-4f1e-9ca9-4335f8cee519",
   "metadata": {},
   "source": [
    "(iii) Multiple inheritance :- "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "1f7f7e74-43d4-4056-89e4-36d82354494c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is first parent's function\n",
      "This is second parent's function\n",
      "this is child class's function\n"
     ]
    }
   ],
   "source": [
    "class parent1:\n",
    "    def function1(self):\n",
    "        print(\"This is first parent's function\")\n",
    "\n",
    "class parent2:  \n",
    "    def function2(self):\n",
    "        print(\"This is second parent's function\")\n",
    "\n",
    "class child(parent1,parent2):    #  is inheriting here.\n",
    "    def function3(self):\n",
    "        print(\"this is child class's function\")\n",
    "\n",
    "obj=child()      # we are able to access all the class through a single class \n",
    "obj.function1()\n",
    "obj.function2()\n",
    "obj.function3()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c57ef08c-b22a-4fe5-8591-1186d2e579db",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7a8e401d-4050-46ca-9611-69f9213eca3a",
   "metadata": {},
   "source": [
    "(iv) Hirarichial inheritance :-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "858f5f3c-b1ef-402f-9521-ed7cc8feb83a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is first class's function\n",
      "This is second class's function\n",
      "this is third class's function\n"
     ]
    }
   ],
   "source": [
    "class parent:\n",
    "    def function(self):\n",
    "        print(\"This is parent's function\")\n",
    "\n",
    "class child1(parent):  \n",
    "    def function2(self):\n",
    "        print(\"This is first child's function\")\n",
    "\n",
    "class child2(child1):    #  is inheriting here.\n",
    "    def function3(self):\n",
    "        print(\"this is second child class's function\")\n",
    "\n",
    "obj=c3()      # we are able to access all the class through a single class \n",
    "obj.function1()\n",
    "obj.function2()\n",
    "obj.function3()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21ab6145-0a73-44ed-a397-cff9426c0125",
   "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
}