Day_5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "acbbd70e",
   "metadata": {},
   "source": [
    "# Day 5 (OOPs)\n",
    "\n",
    "\n",
    "## Practicing python from Basics\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d67f15cd",
   "metadata": {},
   "source": [
    "### Classes and Objects\n",
    "\n",
    "1.  Define a class called `Car` with attributes `make`, `model`, and `year`. Create an object of this class and print its attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ef859aaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "car make ::  Honda\n",
      "car model ::  Civic\n",
      "car year ::  2019\n"
     ]
    }
   ],
   "source": [
    "# Defining class car\n",
    "class Car:\n",
    "    \n",
    "    # defining python special method as a constructor.\n",
    "    def __init__(self, make, model, year):\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        \n",
    "# creating object for class car\n",
    "car1 = Car('Honda','Civic',2019)\n",
    "\n",
    "# printing all attributes\n",
    "print(f\"car make :: \",car1.make)\n",
    "print(f\"car model :: \",car1.model)\n",
    "print(f\"car year :: \",car1.year)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcb7e216",
   "metadata": {},
   "source": [
    "2.  Create a class `Circle` with a method `area()` that calculates and returns the area of the circle. Create an object of this class and call the `area()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9a64c790",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "area of circle for given r is ::  50.24\n"
     ]
    }
   ],
   "source": [
    "# defining class circle\n",
    "class Circle:\n",
    "    \n",
    "    #defining class method\n",
    "    def area(self,r):\n",
    "        pi = 3.14\n",
    "        return pi*(r**2)\n",
    "\n",
    "# creating object for class Circle()\n",
    "circ = Circle()\n",
    "\n",
    "r = 4\n",
    "\n",
    "# calculating area by calling class method\n",
    "area = circ.area(r)\n",
    "print(f\"area of circle for given r is :: \",area)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95ba4d36",
   "metadata": {},
   "source": [
    "3.  Define a class `Student` with attributes `name` and `age`. Create a method `print_details()` that prints the name and age of the student."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5787d853",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "student name ::  Nitin K\n",
      "student age  ::  23\n"
     ]
    }
   ],
   "source": [
    "# defining class Student\n",
    "class Student:\n",
    "    \n",
    "    #defining python special method for constructor\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    # defining class method for printing details\n",
    "    def print_details(self):\n",
    "        print(\"student name :: \",self.name)\n",
    "        print(\"student age  :: \", self.age)\n",
    "\n",
    "# creating object for Student class\n",
    "student1 = Student(name = \"Nitin K\", age = 23)\n",
    "\n",
    "# call print_details() method to print student details\n",
    "student1.print_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11ddb020",
   "metadata": {},
   "source": [
    "### Inheritance in Python\n",
    "4. Create a class `Vehicle` with attributes `make`, `model`, and `year`. Implement a method `display_info()` to print the vehicle's details.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5ea33e51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Honda :: Civic :: 2019\n"
     ]
    }
   ],
   "source": [
    "# Defining class vehicle\n",
    "class Vehicle:\n",
    "    \n",
    "    # Defining constructor method\n",
    "    def __init__(self, make, model, year):\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "    \n",
    "    # Defining display_info() method\n",
    "    def display_info(self):\n",
    "        print(f\"{self.make} :: {self.model} :: {self.year}\")\n",
    "        \n",
    "# creating object for Vehicle class\n",
    "veh1 = Vehicle(\"Honda\", \"Civic\", '2019')\n",
    "\n",
    "# calling display_info() method\n",
    "veh1.display_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc5b44ac",
   "metadata": {},
   "source": [
    "5. Define a subclass `Car` that inherits from `Vehicle` and adds an attribute `fuel_type`. Override the `display_info()` method to include the fuel type.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "db68c674",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Honda :: Civic :: 2014 :: petrol\n"
     ]
    }
   ],
   "source": [
    "# creating a car subcall and inheriting the Vehicle class\n",
    "class Car (Vehicle):\n",
    "    \n",
    "    # defining constructor method\n",
    "    def __init__(self, make, model, year,fuel_type):\n",
    "        super().__init__(make,model,year)\n",
    "        self.fuel_type = fuel_type\n",
    "        \n",
    "    \n",
    "    # defining display_info() method\n",
    "    def display_info(self):\n",
    "        print(f\"{self.make} :: {self.model} :: {self.year} :: {self.fuel_type}\")\n",
    "        \n",
    "\n",
    "# creating a car object\n",
    "car1 = Car('Honda','Civic','2014','petrol')\n",
    "\n",
    "# calling display_info() method\n",
    "car1.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d0882f7",
   "metadata": {},
   "source": [
    "6. Implement another subclass `Bike` that inherits from `Vehicle` and adds an attribute `engine_capacity`. Override the `display_info()` method to include the engine capacity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "85dfae77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "make : avenger :: model : bajaj :: year : 2017 :: Engine Capacity : 240\n"
     ]
    }
   ],
   "source": [
    "# Creating a Bike class and inheriting Vehicle class\n",
    "class Bike(Vehicle):\n",
    "    \n",
    "    # defining constructor method\n",
    "    def __init__(self, make, model, year,engine_capacity):\n",
    "        self.engine_capacity = engine_capacity\n",
    "        \n",
    "        # calling for parent constructor using super() keyword\n",
    "        super().__init__(make,model,year)\n",
    "    \n",
    "    # defining display_info() method\n",
    "    def display_info(self):\n",
    "        print(f\"make : {self.make} :: model : {self.model} :: year : {self.year} :: Engine Capacity : {self.engine_capacity}\")\n",
    "        \n",
    "\n",
    "# creatining bike object\n",
    "bike1 = Bike('avenger','bajaj','2017','240')\n",
    "\n",
    "# Calling display_info() method.\n",
    "bike1.display_info()\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02f065bb",
   "metadata": {},
   "source": [
    "### Polymorphism in Python\n",
    "7. Create a class `Shape` with a method `area()` to calculate and return the area of different shapes. Implement subclasses `Circle`, `Rectangle`, and `Triangle`, each with its own `area()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "adf9baab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- Polymorphism in area of shape --\n",
      "This method prints area of a shape.\n",
      "\n",
      "area of circle for radious 4 is :: 50.24\n",
      "area of triangle for base 2 and height 4 is :: 4.0\n",
      "area of rectangle for length 5 and width 3 is :: 15\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    def info(self):\n",
    "        print(\"-- Polymorphism in area of shape --\")\n",
    "    def area(self):\n",
    "        print(\"This method prints area of a shape.\")\n",
    "\n",
    "class Circle(Shape):\n",
    "    \n",
    "    def area(self,r):\n",
    "        pi = 3.14\n",
    "        area = pi*(r**2)\n",
    "        return f\"area of circle for radious {r} is :: {area}\"\n",
    "\n",
    "class Triangle(Shape):\n",
    "    \n",
    "    def area(self,b,h):\n",
    "        area = 1/2 * (b*h)\n",
    "        return f\"area of triangle for base {b} and height {h} is :: {area}\"\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    \n",
    "    def area(self,l,w):\n",
    "        area = l*w\n",
    "        return f\"area of rectangle for length {l} and width {w} is :: {area}\"\n",
    "    \n",
    "## creating objects\n",
    "shape_obj = Shape()\n",
    "circ_obj = Circle()\n",
    "tri_obj = Triangle()\n",
    "rect_obj = Rectangle()\n",
    "\n",
    "shape_obj.info()\n",
    "shape_obj.area()\n",
    "\n",
    "print()\n",
    "\n",
    "print(circ_obj.area(4))\n",
    "print(tri_obj.area(2,4))\n",
    "print(rect_obj.area(5,3))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1954246",
   "metadata": {},
   "source": [
    "8. Define a class `Animal` with a method `speak()` to make different sounds. Create subclasses `Dog`, `Cat`, and `Cow`, each overriding the `speak()` method with its own sound."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "d0d4eb53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- This method return animal sounds --\n",
      "None\n",
      "\n",
      "Dog says - woof!\n",
      "Cat says - meow!\n",
      "Cow says - moo!\n"
     ]
    }
   ],
   "source": [
    "# creating animal class\n",
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"-- This method return animal sounds --\")\n",
    "\n",
    "# creating Dog class\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return 'woof!'\n",
    "\n",
    "# creating Cat class\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return 'meow!'\n",
    "\n",
    "# creating Cow class\n",
    "class Cow(Animal):\n",
    "    def speak(self):\n",
    "        return 'moo!'\n",
    "\n",
    "# creating objects\n",
    "ani_obj = Animal()\n",
    "dog_obj = Dog()\n",
    "cat_obj = Cat()\n",
    "cow_obj = Cow()\n",
    "\n",
    "# printing\n",
    "print(ani_obj.speak())\n",
    "print(f\"\\nDog says - {dog_obj.speak()}\")\n",
    "print(f\"Cat says - {cat_obj.speak()}\")\n",
    "print(f\"Cow says - {cow_obj.speak()}\")"
   ]
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}