Assignment-1 Week 4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9630b83c",
   "metadata": {},
   "source": [
    "## Q1. Explain Class and Object with respect to Object-Oriented Programming. Give a suitable example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2df1a83",
   "metadata": {},
   "source": [
    "Class: A class is a blueprint or a template for creating objects. It defines the attributes (data) and behaviors (methods) that objects of that class will have. A class acts as a blueprint from which multiple objects can be created, each having its own set of data and behavior. A class acts as a logical entity that encapsulates data and behavior related to a specific concept or entity. Example: Let's consider a class called \"Car\" that represents a car. The class can have attributes like \"color\", \"brand\" and \"model\" and methods like \"start_engine\", \"accelerate\" and \"brake\". The Car class defines the common characteristics and behaviors of all cars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a59bf561",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, color, brand, model):\n",
    "        self.color = color\n",
    "        self.brand = brand\n",
    "        self.model = model\n",
    "    \n",
    "    def start_engine(self):\n",
    "        print(\"Engine started.\")\n",
    "\n",
    "    def accelerate(self):\n",
    "        print(\"Car is accelerating.\")\n",
    "\n",
    "    def brake(self):\n",
    "        print(\"Car is braking.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b131a51",
   "metadata": {},
   "source": [
    "Object: An object is an instance of a class. It is a concrete entity that is created based on the class blueprint. Each object has its own unique set of data and can perform the defined behaviors or methods of the class. Objects are created from classes and can interact with each other to perform operations. Example: Using the Car class mentioned above, we can create individual car objects. For instance, we can create a car object called \"my_car\" with attributes like color = \"red\", brand = \"Toyota\" and model = \"Camry\". This object represents a specific car instance with its unique data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2b681e07",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_car = Car(\"red\", \"Toyota\", \"Camry\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e66ad0b1",
   "metadata": {},
   "source": [
    "Now, \"my_car\" object is an instance of the Car class. It has its own color, brand, and model data, and it can invoke the defined methods such as start_engine(), accelerate(), and brake()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4d7e72bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Engine started.\n"
     ]
    }
   ],
   "source": [
    "my_car.start_engine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "56d00b33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car is accelerating.\n"
     ]
    }
   ],
   "source": [
    "my_car.accelerate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0b2205b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car is braking.\n"
     ]
    }
   ],
   "source": [
    "my_car.brake()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5beb4086",
   "metadata": {},
   "source": [
    "## Q2. Name the four pillars of OOPs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d922e26",
   "metadata": {},
   "source": [
    "The four pillars of OOPs are:\n",
    "\n",
    "(1) Encapsulation: Encapsulation is the bundling of data and methods within a class, hiding the internal details and providing controlled access to the data. It ensures data protection and improves code organization and reusability.\n",
    "\n",
    "(2) Abstraction: Abstraction focuses on representing essential features and behaviors while hiding unnecessary details. It involves creating abstract classes or interfaces that define common attributes and methods without providing implementation details.\n",
    "\n",
    "(3) Inheritance: Inheritance allows classes to inherit properties and methods from other classes. It promotes code reuse, hierarchical organization, and the creation of specialized classes (derived classes) based on existing classes (base or parent classes).\n",
    "\n",
    "(4) Polymorphism: Polymorphism refers to the ability of objects to take on different forms or have different behaviors based on the context. It allows objects of different classes to be treated as objects of a common base class, enabling flexibility and code extensibility."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c049ea6",
   "metadata": {},
   "source": [
    "## Q3. Explain why the __init__() function is used. Give a suitable example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff6cdabc",
   "metadata": {},
   "source": [
    "The 'init()' function in Python is a special method that is automatically called when an object is created from a class. It is used to initialize the object's attributes or perform any necessary setup actions. The \"init\" method allows us to specify the initial state or values of the object. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "798b3058",
   "metadata": {},
   "outputs": [],
   "source": [
    "class pwskills:\n",
    "    def __init__(self, phone_number, email_id, student_id):\n",
    "        self.phone_number = phone_number\n",
    "        self.email_id = email_id\n",
    "        self.student_id = student_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9ab2c558",
   "metadata": {},
   "outputs": [],
   "source": [
    "pw = pwskills(22222222222, \"rohan@gmail.com\", 10040)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a06ed738",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22222222222"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw.phone_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bbe21165",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'rohan@gmail.com'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw.email_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ade5b43a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10040"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pw.student_id"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bb7a1ce",
   "metadata": {},
   "source": [
    "## Q4. Why self is used in OOPs?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a495ce2b",
   "metadata": {},
   "source": [
    "In OOPs, \"self\" is used as a reference to the current instance of a class. It is a convention in Python to name the first parameter of a class method as \"self\" (though any name can be used). When an object calls a method, it automatically passes itself as the first argument to the method using the \"self\" parameter.\n",
    "\n",
    "By using \"self\", we can access the attributes and methods of the current object within the class. It allows us to manipulate and work with the object's data and perform actions on it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd9ac40f",
   "metadata": {},
   "source": [
    "## Q5. What is inheritance? Give an example for each type of inheritance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41b8f80b",
   "metadata": {},
   "source": [
    "Inheritance is a fundamental concept in object-oriented programming that allows a class to inherit properties and methods from another class. It promotes code reuse, hierarchy, and specialization.\n",
    "\n",
    "There are different types of inheritance:\n",
    "\n",
    "(1) Single Inheritance: A class inherits from a single base or parent class. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "81c015d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vehicle:\n",
    "    def drive(self):\n",
    "        print(\"Driving a vehicle\")\n",
    "\n",
    "class Car(Vehicle):\n",
    "    def accelerate(self):\n",
    "        print(\"Accelerating the car\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d497aa6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_car = Car()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a7646678",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Driving a vehicle\n"
     ]
    }
   ],
   "source": [
    "my_car.drive() # Accessing inherited method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "372cb5e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accelerating the car\n"
     ]
    }
   ],
   "source": [
    "my_car.accelerate() # Accessing its own method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd71963b",
   "metadata": {},
   "source": [
    "(2) Multiple Inheritance: A class can inherit from multiple base or parent classes. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "69ede62b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def method_A(self):\n",
    "        print(\"Method A from class A\")\n",
    "\n",
    "class B:\n",
    "    def method_B(self):\n",
    "        print(\"Method B from class B\")\n",
    "\n",
    "class C(A, B):\n",
    "    def method_C(self):\n",
    "        print(\"Method C from class C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f0ae667e",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_object = C()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "257e2e63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method A from class A\n"
     ]
    }
   ],
   "source": [
    "my_object.method_A() # Accessing method from class A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7cdffaf9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method B from class B\n"
     ]
    }
   ],
   "source": [
    "my_object.method_B() # Accessing method from class B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "99f76ae8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method C from class C\n"
     ]
    }
   ],
   "source": [
    "my_object.method_C() # Accessing its own method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88892c61",
   "metadata": {},
   "source": [
    "(3) Multilevel Inheritance: A class inherits from another derived class, forming a hierarchy. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "0c8ab80f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def breathe(self):\n",
    "        print(\"Breathing\")\n",
    "\n",
    "class Mammal(Animal):\n",
    "    def feed_milk(self):\n",
    "        print(\"Feeding milk\")\n",
    "\n",
    "class Dog(Mammal):\n",
    "    def bark(self):\n",
    "        print(\"Barking\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a69bb560",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dog = Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "95b1a78c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Breathing\n"
     ]
    }
   ],
   "source": [
    "my_dog.breathe() # Accessing method from class Animal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c22b0d9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feeding milk\n"
     ]
    }
   ],
   "source": [
    "my_dog.feed_milk() # Accessing method from class Mammal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8ea997c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Barking\n"
     ]
    }
   ],
   "source": [
    "my_dog.bark() # Accessing its own method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c56b7573",
   "metadata": {},
   "source": [
    "(4) Hierarchical Inheritance: Multiple classes inherit from a single base or parent class. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b6d07721",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Shape:\n",
    "    def draw(self):\n",
    "        print(\"Drawing a shape\")\n",
    "\n",
    "class Circle(Shape):\n",
    "    def calculate_area(self):\n",
    "        print(\"Calculating the area of a circle\")\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def calculate_area(self):\n",
    "        print(\"Calculating the area of a rectangle\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "32c2a880",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_circle = Circle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5768f319",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_rectangle = Rectangle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "87636394",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drawing a shape\n"
     ]
    }
   ],
   "source": [
    "my_circle.draw() # Accessing inherited method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f3957d16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating the area of a circle\n"
     ]
    }
   ],
   "source": [
    "my_circle.calculate_area() # Accessing its own method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e9b992d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drawing a shape\n"
     ]
    }
   ],
   "source": [
    "my_rectangle.draw() # Accessing inherited method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "89e557de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating the area of a rectangle\n"
     ]
    }
   ],
   "source": [
    "my_rectangle.calculate_area() # Accessing its own method"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}