9th Feb 2023 (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "52ca4b80-75b0-42fc-847b-c16ec434a5c8",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 9th Feb Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3becb597-68bc-4760-8078-d5cba151e664",
   "metadata": {},
   "source": [
    "```\n",
    "Q1. Create a vehicle class with an init method having instance variables as name_of_vehicle, max_speed and average_of_vehicle.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e19c7175-17d6-4923-9659-678f38143f01",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q1 Answer\n",
    "class vehicle:\n",
    "    def __init__ (self, name_of_vehicle, max_speed, average_of_vehicle):\n",
    "        self.name_of_vehicle = name_of_vehicle\n",
    "        self.max_speed = max_speed\n",
    "        self.average_of_vehicle = average_of_vehicle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f2def626-bb38-41c8-8717-2d86937faa91",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = vehicle(\"Tata Punch\", 220, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "96e904ef-8547-4840-9ff7-1a9af5be410c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tata Punch\n",
      "220\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "print(car.name_of_vehicle)\n",
    "print(car.max_speed)\n",
    "print(car.average_of_vehicle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0d1ffdf-3408-4d7b-9c99-41f59f307e09",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dcd856f-d1ab-4a93-8993-b8579b4ecfd8",
   "metadata": {},
   "source": [
    "```\n",
    "Q2. Create a child class car from the vehicle class created in Que 1, which will inherit the vehicle class. Create a method named seating_capacity which takes capacity as an argument and returns the name of the vehicle and its seating capacity.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0ea89e87-741b-4fd1-ae59-f6c8fe4848bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q2 Answer\n",
    "class car(vehicle):\n",
    "    def seating_capacity (self, capacity):\n",
    "        return f\"The Seating Capacity of {self.name_of_vehicle} is {capacity}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9271f9a7-3c42-49a2-b991-afcc242b639b",
   "metadata": {},
   "outputs": [],
   "source": [
    "car1 = car(\"Tata Punch\", 220, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ac94584e-c36b-4f53-b396-22e6723dec5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The Seating Capacity of Tata Punch is 5'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car1.seating_capacity(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01497315-54d6-4098-998b-1bf4bb24d22a",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f14de9c0-6220-42c3-b7a3-7b7cb7a6be5c",
   "metadata": {},
   "source": [
    "```\n",
    "Q3. What is multiple inheritance? Write a python code to demonstrate multiple inheritance.\n",
    "\n",
    "Ans. Multiple inheritance: A subclass inherits from multiple base classes.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "27c5fae4-3c7f-4860-bafd-11da6399aad3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some mammal sound\n",
      "Swimming\n"
     ]
    }
   ],
   "source": [
    "class Mammal:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    \n",
    "    def make_sound(self):\n",
    "        print(\"Some mammal sound\")\n",
    "\n",
    "class Fish:\n",
    "    def swim(self):\n",
    "        print(\"Swimming\")\n",
    "\n",
    "class Dolphin(Mammal, Fish):\n",
    "    pass\n",
    "\n",
    "dolphin = Dolphin(\"Flipper\")\n",
    "dolphin.make_sound()\n",
    "dolphin.swim()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83f72e18-136a-4f0a-ac26-358f2e7ec44a",
   "metadata": {},
   "source": [
    "```\n",
    "In this example, the Dolphin class inherits from both the Mammal and Fish classes.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ca43087-9260-479d-bfdc-46cde246ac5e",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12f5988d-cc61-4c02-a0e3-3e907fbd8c3b",
   "metadata": {},
   "source": [
    "```\n",
    "Q4. What are getter and setter in python? Create a class and create a getter and a setter method in this class.\n",
    "\n",
    "Ans. In object-oriented programming, getter and setter methods are used to retrieve or set the values of instance variables. They provide a way to encapsulate the internal state of an object and control access to it, making it easier to maintain and modify the code.\n",
    "\n",
    "Here's an example of a simple class in Python with a getter and a setter method:\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "00b92682-65fc-43a2-890e-c9141b8e9d61",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self._name = name\n",
    "        self._age = age\n",
    "\n",
    "    def get_name(self):\n",
    "        return self._name\n",
    "\n",
    "    def set_name(self, name):\n",
    "        self._name = name\n",
    "\n",
    "    def get_age(self):\n",
    "        return self._age\n",
    "\n",
    "    def set_age(self, age):\n",
    "        self._age = age"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1c73bcd-8089-41c3-9185-32c51175316c",
   "metadata": {},
   "source": [
    "```\n",
    "The Person class has two instance variables: _name and _age. The underscore before the variable names is a convention in Python to indicate that they are meant to be private, although they can still be accessed directly if needed.\n",
    "\n",
    "The get_name and get_age methods are getter methods that return the values of the _name and _age instance variables, respectively. The set_name and set_age methods are setter methods that allow you to set the values of the _name and _age instance variables.\n",
    "\n",
    "You can create an instance of the Person class like this:\n",
    "```    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "90a1809a-3489-40b7-941b-ec589e91d8b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "person = Person(\"lalit\", 18)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c293b8f-8a8a-4059-aa1e-172d904e80ae",
   "metadata": {},
   "source": [
    "```\n",
    "And use the getter and setter methods like this:\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1249622b-8f4c-4253-8778-149c4f12b270",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lalit\n",
      "18\n",
      "lalit\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "print(person.get_name()) \n",
    "print(person.get_age()) \n",
    "\n",
    "person.set_name(\"lalit\")\n",
    "person.set_age(18)\n",
    "\n",
    "print(person.get_name()) \n",
    "print(person.get_age()) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2e84313-6d57-4b06-9704-23ad0c5c5a22",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6342988-cdcd-47fd-b23f-3a4b6bc19ddf",
   "metadata": {},
   "source": [
    "```\n",
    "Q5. What is method overriding in python? Write a python code to demonstrate method overriding.\n",
    "\n",
    "Ans. In object-oriented programming, method overriding is the ability of a subclass to provide a different implementation of a method that is already defined in its parent class. This allows the subclass to inherit the behavior of the parent class but to modify it as needed to fit its specific needs.\n",
    "\n",
    "Here's a simple example of method overriding in Python:\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a90e90ff-4a3f-43b7-aced-2a6aaa4683ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Shape:\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return 3.14 * self.radius * self.radius"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03fb3c3e-584a-4ce6-a3fc-e6bb7eaf99b4",
   "metadata": {},
   "source": [
    "```\n",
    "The Shape class defines a area method but does not provide an implementation for it. This is a common pattern in Python when you want to define an interface that can be implemented by subclasses.\n",
    "\n",
    "The Rectangle and Circle classes both inherit from the Shape class and provide their own implementations of the area method. The Rectangle class calculates the area as the product of its width and height, while the Circle class calculates the area as the product of 3.14 and the square of its radius.\n",
    "\n",
    "You can create instances of the Rectangle and Circle classes and call their area methods like this:\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b536736e-8f81-4b88-bd87-d6bb86ae30fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "78.5\n"
     ]
    }
   ],
   "source": [
    "rect = Rectangle(10, 20)\n",
    "print(rect.area())\n",
    "\n",
    "circle = Circle(5)\n",
    "print(circle.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "056b8163-ee78-4450-8ddf-948ef76f1dbf",
   "metadata": {},
   "source": [
    "```\n",
    "In this example, the Rectangle and Circle classes have overridden the area method from the Shape class, providing their own custom implementations that match their specific needs.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e65f4c47-fd94-4b82-8846-bed9505764b9",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}