5.assighnment)5_01.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44be63a4-ccf7-4c0d-887c-ccd992a6598e",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q1. Explain Class and Object with respect to Object-Oriented Programming.\n",
    "Give a suitable example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4bea9dfc-1186-4c76-a307-76bd6e3ec968",
   "metadata": {},
   "outputs": [],
   "source": [
    "In object - oriented programming(OOP),a class is a blueprint or template for creting objects (instaces).\n",
    "It defines the attributes(data) and methods(fuctions) that each object of that class will posses.\n",
    "An object , on the other hand,is a concrete instances of a class.\n",
    "It represents a specific entity that has state (attributes) and behavior(method) defines by its class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "04f3a192-ad8f-485b-ba8b-e19c8e8c1488",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020 Toyota Corolla\n",
      "This car has 0 miles on it.\n",
      "This car has 100 miles on it.\n"
     ]
    }
   ],
   "source": [
    "# Define a class called Car\n",
    "class Car:\n",
    "    # Constructor method to initialize the car's attributes\n",
    "    def __init__(self, make, model, year):\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        self.odometer_reading = 0  # Default value for odometer reading\n",
    "\n",
    "    # Method to describe the car\n",
    "    def describe_car(self):\n",
    "        description = f\"{self.year} {self.make} {self.model}\"\n",
    "        return description\n",
    "\n",
    "    # Method to read the odometer\n",
    "    def read_odometer(self):\n",
    "        return f\"This car has {self.odometer_reading} miles on it.\"\n",
    "\n",
    "    # Method to update the odometer reading\n",
    "    def update_odometer(self, mileage):\n",
    "        if mileage >= self.odometer_reading:\n",
    "            self.odometer_reading = mileage\n",
    "        else:\n",
    "            print(\"You can't roll back an odometer!\")\n",
    "\n",
    "\n",
    "# Create an object (instance) of the Car class\n",
    "my_car = Car(\"Toyota\", \"Corolla\", 2020)\n",
    "\n",
    "# Accessing attributes and calling methods of the object\n",
    "print(my_car.describe_car())  # Output: 2020 Toyota Corolla\n",
    "print(my_car.read_odometer())  # Output: This car has 0 miles on it.\n",
    "\n",
    "# Update the odometer reading\n",
    "my_car.update_odometer(100)\n",
    "print(my_car.read_odometer())  # Output: This car has 100 miles on it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6cd7fc4-26ec-4ac0-a619-8c7f84dd678d",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q2. Name the four pillars of OOPs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7285752-63d5-4c6e-99a8-4024b8fea0c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "The four pillars of object-oriented programming (OOP) are:\n",
    "\n",
    "1. Encapsulation: \n",
    "    Encapsulation refers to the bundling of data (attributes) and methods (functions) that operate on the data into a single unit or class. \n",
    "    It hides the internal state of an object from the outside world and only exposes the necessary functionalities through well-defined interfaces.\n",
    "\n",
    "2. Abstraction: \n",
    "    Abstraction is the process of hiding the implementation details of a class and showing only the essential features of the object. \n",
    "    It allows programmers to focus on what an object does rather than how it does it, enabling code reusability and simplifying complex systems.\n",
    "\n",
    "3. Inheritance:\n",
    "    Inheritance is a mechanism by which a class (subclass or derived class) can inherit properties and behavior (attributes and methods) from another class (superclass or base class). \n",
    "    It promotes code reusability and establishes a hierarchical relationship among classes.\n",
    "\n",
    "4. Polymorphism: \n",
    "    Polymorphism allows objects of different classes to be treated as objects of a common superclass. \n",
    "    It enables a single interface to represent different types of objects and allows methods to behave differently based on the object they are operating on.\n",
    "    Polymorphism can be achieved through method overloading and method overriding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "891c52ec-142b-488c-ab39-6e6587c2a615",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q3. Explain why the __init__() function is used.\n",
    "Give a suitable example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd2f6118-90ba-4079-9921-3b183d6d8565",
   "metadata": {},
   "outputs": [],
   "source": [
    "The __init__() function in Python is a special method (also known as a constructor) that is automatically called when a new instance of a class is created.\n",
    "Its primary purpose is to initialize the newly created object's attributes or perform any setup necessary for the object to function properly. \n",
    "This method allows you to specify initial values for the object's attributes when it is created.\n",
    "\n",
    "Here's why the __init__() function is used:\n",
    "\n",
    "Attribute Initialization: It allows you to initialize the object's attributes with values passed as arguments when the object is created. This ensures that the object starts with the desired initial state.\n",
    "Setup and Configuration: It provides a convenient place to perform any setup or configuration tasks required for the object to function correctly. This could include initializing internal variables, setting default values, or even connecting to databases or external resources.\n",
    "Enforcement of Constraints: The __init__() method can also enforce constraints or perform validation checks on the initial values provided, ensuring that the object is instantiated with valid data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9f12f887-2fe5-401e-b37a-f6eeb2bb2086",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name:Alice,Age:30\n",
      "Name:Bob,Age:25\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    def display_info(self):\n",
    "        print(f\"Name:{self.name},Age:{self.age}\")\n",
    "#Creating instances of the Person class\n",
    "person1 = Person(\"Alice\",30)\n",
    "person2 = Person(\"Bob\",25)\n",
    "#Displaying information about the persons\n",
    "person1.display_info() \n",
    "person2.display_info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53393974-cf0b-437e-ad62-31c390325a0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q4. Why self is used in OOPs?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "078f6de1-627f-4d4c-b937-e0a41b281198",
   "metadata": {},
   "outputs": [],
   "source": [
    "In object-oriented programming (OOP), self is a convention used in many programming languages (such as Python) to refer to the current instance of a class. It is a reference to the object itself. Here's why self is used:\n",
    "\n",
    "Accessing Instance Variables: Within the methods of a class, self is used to access instance variables (attributes) of the object. It allows methods to refer to the specific instance's data.\n",
    "Calling Other Methods: self is also used to call other methods within the same class. This allows methods to interact with other methods and access the object's behavior.\n",
    "Identifying Instance Scope: By using self, it distinguishes between instance variables and local variables or parameters within methods. It clarifies that the variable belongs to the object's instance and not just to the method's scope.\n",
    "Creating New Attributes: When defining new attributes within methods or the __init__() method, self is used to bind those attributes to the object instance, making them accessible throughout the object's lifespan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d8514c88-3988-40e3-8892-9ee4bdaae91c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of x: 5\n",
      "Value of x: 10\n"
     ]
    }
   ],
   "source": [
    "#Here's a simple example to illustrate the usage of self in Python:\n",
    "class MyClass:\n",
    "    def __init__(self,x):\n",
    "        self.x = x\n",
    "        \n",
    "    def display(self):\n",
    "        print(\"Value of x:\",self.x)\n",
    "        \n",
    "    def update(self,new_x):\n",
    "        self.x = new_x\n",
    "#Creating an instances of MyClass\n",
    "obj = MyClass(5)\n",
    "#Calling methods using the object and accesing instance variable\n",
    "obj.display()\n",
    "obj.update(10)\n",
    "obj.display()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1313324a-d076-4cd9-9338-1c75a598959e",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q5. What is inheritance? \n",
    "Give an example for each type of inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69be87ba-9717-4886-a8ea-6cad35ce3338",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "Inheritance is a fundamental concept in object-oriented programming (OOP) where a new class (subclass or derived class) is created by inheriting attributes and methods from an existing class (superclass or base class). \n",
    "The subclass inherits the properties and behavior of the superclass and can also add new features or modify existing ones.\n",
    "There are different types of inheritance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc7904ef-12e0-4ba6-890c-0a411e6603c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "1.Single Inheritance:\n",
    "    In single inheritance, a subclass inherits from only one superclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "dcaf3fc1-ea2a-4b25-81c9-68c95d4b7f33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal speaks\n",
      "Dog barks\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Animal speaks\")\n",
    "class Dog(Animal): \n",
    "    def bark(self):\n",
    "        print(\"Dog barks\")\n",
    "#Dog inherites from Animal\n",
    "#Creating an intaces of Dog \n",
    "dog = Dog()\n",
    "dog.speak()\n",
    "dog.bark()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ab44c23-b0f2-4075-ac91-eb5c889e3aa0",
   "metadata": {},
   "outputs": [],
   "source": [
    "2.Multiple Inheritance:\n",
    "    Multiple inheritance occurs when a subclass inherits from more than one superclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "31b4e6a0-8864-4646-b0b2-d1c008152a7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal speaks\n",
      "Flying\n"
     ]
    }
   ],
   "source": [
    "class Flyable:\n",
    "    def fly(self):\n",
    "        print(\"Flying\")\n",
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Animal speaks\")\n",
    "#Bird inherites from bothes Animal and Flyable\n",
    "class Bird(Animal,Flyable):\n",
    "    pass\n",
    "#Creating an intance of Bird\n",
    "bird = Bird()\n",
    "bird.speak()\n",
    "bird.fly()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a45b2605-f7ed-47e4-aecf-905e34522162",
   "metadata": {},
   "outputs": [],
   "source": [
    "3.Multilevel Inheritance:\n",
    "    Multilevel inheritance involves inheriting from a superclass, then creating another class that inherits from the subclass, forming a chain of inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e0ce152a-a106-4994-ad1e-60cc422e1c8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal speaks\n",
      "Dog barks\n",
      "Labrador is golden\n"
     ]
    }
   ],
   "source": [
    "class Animals:\n",
    "    def speak(self):\n",
    "        print(\"Animals speaks\")\n",
    "#Dog inherites from Animal        \n",
    "class Dog(Animal):\n",
    "    def bark(self):\n",
    "        print(\"Dog barks\")\n",
    "#Labrador inherits from Dog       \n",
    "class Labrador(Dog):\n",
    "    def color(self):\n",
    "        print(\"Labrador is golden\")\n",
    "#Creating an instaces of Labrador \n",
    "labrador = Labrador()\n",
    "labrador.speak()\n",
    "labrador.bark()\n",
    "labrador.color()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "523a19aa-4aeb-4a67-967e-baf4c8ded947",
   "metadata": {},
   "outputs": [],
   "source": [
    "4.Hierarchical Inheritance: \n",
    "    Hierarchical inheritance involves multiple subclasses inheriting from the same superclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f3898e19-632a-4f97-b6a8-9808e8237999",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animals speaks\n",
      "Dog barks\n",
      "Animals speaks\n",
      "Cat meows\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Animals speaks\")\n",
    "#Dog inherites from Animals\n",
    "class Dog(Animal):\n",
    "    def bark(self):\n",
    "        print(\"Dog barks\")\n",
    "#Cats inherites from Animals\n",
    "class Cat(Animal):\n",
    "    def meow(self):\n",
    "        print(\"Cat meows\")\n",
    "        \n",
    "#Creating intances of Dog and Cat\n",
    "dog = Dog()\n",
    "dog.speak()\n",
    "dog.bark()\n",
    "\n",
    "cat = Cat()\n",
    "cat.speak()\n",
    "cat.meow()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7df7730d-e01d-4417-86df-264a364fe397",
   "metadata": {},
   "outputs": [],
   "source": [
    "In each of these examples, inheritance enables code reuse and promotes a hierarchical structure, allowing subclasses to inherit and extend the functionality of their superclass(es)."
   ]
  }
 ],
 "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
}