15th_OCT_oops assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c693cc4a-7aa8-49a9-93ba-51c8c44463a6",
   "metadata": {},
   "source": [
    "                                                         OOPS Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28813649-9d08-47d6-bfe5-4d3cd7eff2ca",
   "metadata": {},
   "source": [
    "                                                     Constructor:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00e305f3-d294-41bb-9e82-feb156ee9fd8",
   "metadata": {},
   "source": [
    "Q1. What is a constructor in Python? Explain its purpose and usage."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61dbbd4c-881f-45dd-b7fa-c1c497c822de",
   "metadata": {},
   "source": [
    "Definition: A constructor is a special method called __init__() in Python, automatically invoked when an object of a class is created.\n",
    "\n",
    "Purpose: It initializes the object's attributes and performs setup tasks.\n",
    "\n",
    "Usage: Declared within a class using the def __init__(self, ...) syntax."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fc42951-135b-460b-b33a-3c9e0ade0d45",
   "metadata": {},
   "source": [
    "Q2. Differentiate between a parameterless constructor and a parameterized constructor in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6e7c0e4-eb66-491a-8adf-bb7395cfaee8",
   "metadata": {},
   "source": [
    "Parameterless Constructor:\n",
    "\n",
    "Definition- Constructor with no parameters (other than self).\n",
    "\n",
    "Purpose- Used for initializing default values.\t\n",
    "\n",
    "Syntax\tdef __init__(self)\n",
    " \n",
    "Parameterized Constructor:\n",
    "\n",
    "Definition- Constructor with parameters to pass custom values.\n",
    "\n",
    "Purpose- Used for initializing with user-provided values.\n",
    "\n",
    "Syntax- def __init__(self, param1, param2, ...):"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68104126-8bb1-4a22-a39d-1e30eb10b721",
   "metadata": {},
   "source": [
    "Q3. How do you define a constructor in a Python class? Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "82aa972e-09bd-4e00-8438-4e4df18fa53b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A constructor is defined using the __init__() method inside a class.\\\n",
    "#example\n",
    "\n",
    "class Car:\n",
    "    def __init__(self, brand, model):  \n",
    "        self.brand = brand\n",
    "        self.model = model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b894b84-6ab9-4d98-b194-e481167c3811",
   "metadata": {},
   "source": [
    "4. Explain the __init__ method in Python and its role in constructors."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6001d11b-553d-43d2-9198-0ad4cf216c44",
   "metadata": {},
   "source": [
    "__init__ Method in Python:\n",
    "\n",
    "    Definition: __init__ is a special method that acts as a constructor in Python. It initializes an object's attributes when it is created.\n",
    "\n",
    "Role in Constructors:\n",
    "\n",
    "    Sets up the initial state of the object.\n",
    "    Automatically called when an object is instantiated.\n",
    "    Enables passing arguments to set custom values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6552265b-0e97-4551-9276-a3c374a87e62",
   "metadata": {},
   "source": [
    "Q5. In a class named `Person`, create a constructor that initializes the `name` and `age` attributes. Provide an\n",
    "example of creating an object of this class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "36363224-5b26-43aa-9fbe-7b355e546226",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amit\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "#Class with Constructor Example:\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, age):  \n",
    "        self.name = name  \n",
    "        self.age = age  \n",
    "\n",
    "# Creating an object of the class\n",
    "person1 = Person(\"Amit\", 28)\n",
    "\n",
    "# Accessing attributes\n",
    "print(person1.name)   \n",
    "print(person1.age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c782c2b6-e514-462f-973b-a48fbd5409ce",
   "metadata": {},
   "source": [
    "Q6. How can you call a constructor explicitly in Python? Give an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d58f6b89-3436-41ce-a817-e77c4614918a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Explicitly Calling a Constructor in Python:\n",
    "\n",
    "    #You can explicitly call a constructor using the class name, passing the required arguments.\n",
    "    #However, explicit calls to __init__ are rare since it is automatically invoked during object creation.\n",
    "\n",
    "#Example:\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "person = Person.__init__(Person, \"AMIT\", 28)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01988793-b4b6-4f3c-8938-4461aeca7b73",
   "metadata": {},
   "source": [
    "Q7. What is the significance of the `self` parameter in Python constructors? Explain with an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "5cb2f8ad-7327-4bba-b741-9dbf32cdb889",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amit\n",
      "28\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Key Points:\\n\\n    self is not a keyword, but a convention.\\n    It must be the first parameter in instance methods and constructors.\\n    It allows each object to store its own data.'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''Significance of self in Python Constructors:\n",
    "\n",
    "    self is a reference to the current instance of the class. It allows access to the instance's attributes and methods within the class.\n",
    "    It is used to differentiate between instance variables (attributes) and local variables.\n",
    "    In constructors (__init__), self allows initialization of the object's attributes.\n",
    "\n",
    "Example:\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, age):  # self refers to the current object\n",
    "        self.name = name  # Assign name to instance variable\n",
    "        self.age = age    # Assign age to instance variable'''\n",
    "\n",
    "\n",
    "person1 = Person(\"Amit\", 28)\n",
    " \n",
    "print(person1.name)   \n",
    "print(person1.age)    \n",
    "\n",
    "'''Key Points:\n",
    "\n",
    "    self is not a keyword, but a convention.\n",
    "    It must be the first parameter in instance methods and constructors.\n",
    "    It allows each object to store its own data.'''\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b68dd9e-2330-4f58-98e5-c964691654a7",
   "metadata": {},
   "source": [
    "Q8. Discuss the concept of default constructors in Python. When are they used?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc630e92-a50e-4d2c-a57b-6b0d4a5de0b1",
   "metadata": {},
   "source": [
    "Default ConstructorDefault Constructors in Python:\n",
    "\n",
    "Definition: A ddefault constructor is a constructor that does not take any parameters other than self.\n",
    "It initializes object attributes with default values or leaves them uninitialized.\n",
    " \n",
    "Usage: Default constructors are used when an object can be created without any initial values, and\n",
    "the attributes can be assigned default values within the constructor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4797eff-137f-49a6-990a-793ac24b2bfc",
   "metadata": {},
   "source": [
    "Q9. Create a Python class called `Rectangle` with a constructor that initializes the `width` and `height`\n",
    "attributes. Provide a method to calculate the area of the rectangle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "b67d2b89-639d-4875-9ed7-74d05262a519",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of Rectangle: 15\n"
     ]
    }
   ],
   "source": [
    "# Python Class Rectangle with Constructor and Area Method:\n",
    "\n",
    "class Rectangle:\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",
    "rect = Rectangle(5, 3)\n",
    " \n",
    "print(\"Area of Rectangle:\", rect.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "080e9171-21a9-45fc-b890-246ce3340f68",
   "metadata": {},
   "source": [
    "Q10. How can you have multiple constructors in a Python class? Explain with an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e0964933-f82a-47e9-8a77-c8d1900385ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of rect1: 15\n",
      "Area of rect2: 0\n",
      "Area of rect1: 15\n",
      "Area of rect2: 16\n"
     ]
    }
   ],
   "source": [
    "# Method 1: Using Default Arguments\n",
    "\n",
    "# You can provide default values for parameters in the __init__ method to handle different initialization scenarios.\n",
    "# Example:\n",
    "\n",
    "class Rectangle:\n",
    "    def __init__(self, width=0, height=0):   \n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    " \n",
    "rect1 = Rectangle(5, 3)  \n",
    "rect2 = Rectangle()      \n",
    "\n",
    "print(\"Area of rect1:\", rect1.area())  \n",
    "print(\"Area of rect2:\", rect2.area())  \n",
    "\n",
    "# Method 2: Using Class Methods to Simulate Multiple Constructors\n",
    "\n",
    "# Another approach is to define class methods that act as alternative constructors. These methods can be used to create objects in different ways.\n",
    "# Example:\n",
    "\n",
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    @classmethod\n",
    "    def from_square(cls, side_length):  \n",
    "        return cls(side_length, side_length)\n",
    "\n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    " \n",
    "rect1 = Rectangle(5, 3)              \n",
    "rect2 = Rectangle.from_square(4)     \n",
    "\n",
    "print(\"Area of rect1:\", rect1.area())  \n",
    "print(\"Area of rect2:\", rect2.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "040d8380-af78-4691-bac7-d8f6d6b3c3e9",
   "metadata": {},
   "source": [
    "Q11. What is method overloading, and how is it related to constructors in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d1d0c4d-c679-478f-aa5a-a9e19b00d4c2",
   "metadata": {},
   "source": [
    "Method Overloading in Python:\n",
    "\n",
    "    Definition: Method overloading refers to the ability to define multiple methods with the same name but with different parameter types or numbers of arguments.\n",
    "    Python's Behavior: Unlike some other languages like Java or C++, Python does not support traditional method overloading. However, you can achieve similar behavior by handling varying arguments within a single method using default parameters or variable-length argument lists.\n",
    "\n",
    "Relation to Constructors:\n",
    "\n",
    "In the case of constructors (__init__ method), method overloading can be simulated by defining one constructor that accepts different numbers of arguments or by using class methods to provide alternative ways to instantiate an object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c33d41bc-a818-4113-986a-67657ec8cae7",
   "metadata": {},
   "source": [
    "Q12. Explain the use of the `super()` function in Python constructors. Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "174619e8-77c9-4a61-8bdc-90e5a9e3dc62",
   "metadata": {},
   "source": [
    "The super() Function in Python Constructors:\n",
    "\n",
    "    Definition: The super() function is used to call methods from a parent (or superclass) in a class. It allows you to invoke the constructor (__init__ method) of the base class, enabling you to initialize the attributes of the parent class in a child class constructor.\n",
    "    Use Case: It is commonly used in inheritance when a subclass wants to extend the behavior of the parent class’s constructor.\n",
    "\n",
    "Purpose of super() in Constructors:\n",
    "\n",
    "    It ensures that the parent class is properly initialized before the child class adds its own initialization logic.\n",
    "    It helps avoid directly referring to the parent class by name, which makes the code more maintainable and supports multiple inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "289dc4d3-091f-4a07-853b-c4ed6522a89e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal constructor called for Buddy\n",
      "Dog constructor called for Golden Retriever breed\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        print(f\"Animal constructor called for {self.name}\")\n",
    "\n",
    "class Dog(Animal):   \n",
    "    def __init__(self, name, breed):\n",
    "        super().__init__(name)   \n",
    "        self.breed = breed\n",
    "        print(f\"Dog constructor called for {self.breed} breed\")\n",
    " \n",
    "dog1 = Dog(\"Buddy\", \"Golden Retriever\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39a52b90-4420-4df2-9281-17f3928f0d48",
   "metadata": {},
   "source": [
    "Q13. Create a class called `Book` with a constructor that initializes the `title`, `author`, and `published_year`\n",
    "attributes. Provide a method to display book details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "fd22227f-4397-4dec-9e5e-9bb31b3b61c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Title: The Great Gatsby\n",
      "Author: F. Scott Fitzgerald\n",
      "Published Year: 1925\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author, published_year):\n",
    "        self.title = title            \n",
    "        self.author = author          \n",
    "        self.published_year = published_year   \n",
    "\n",
    "    def display_details(self):\n",
    "        \n",
    "        print(f\"Title: {self.title}\")\n",
    "        print(f\"Author: {self.author}\")\n",
    "        print(f\"Published Year: {self.published_year}\")\n",
    " \n",
    "book1 = Book(\"The Great Gatsby\", \"F. Scott Fitzgerald\", 1925)\n",
    "book1.display_details()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf38ca4f-9de1-46d9-b9a2-793350a7926f",
   "metadata": {},
   "source": [
    "Q14. Discuss the differences between constructors and regular methods in Python classes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5abfa097-cf32-4e31-8bc1-2ab6028701cc",
   "metadata": {},
   "source": [
    "Definition- A constructor is a special method (__init__) that initializes an object when it is created.\n",
    "\n",
    "Definition- A regular method is a function defined inside a class to perform actions on an object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36211d4e-ea04-4630-b2a7-7e7dbe47f520",
   "metadata": {},
   "source": [
    "Q15. Explain the role of the `self` parameter in instance variable initialization within a constructor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4dda938-e2bf-43f9-8f2d-aa550a82b323",
   "metadata": {},
   "source": [
    "Role of self in Instance Variable Initialization within a Constructor:\n",
    "\n",
    "    Definition of self:\n",
    "        In Python, self refers to the current instance of the class. It allows the instance to access its own attributes and methods.\n",
    "\n",
    "    Role in Constructor:\n",
    "        Within a constructor (__init__), self is used to initialize instance variables (attributes) of the object.\n",
    "        By using self, each instance of the class can store its own unique data, even if they belong to the same class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e0feba1-36c3-4ad0-831b-c22037662e63",
   "metadata": {},
   "source": [
    "Q16. How do you prevent a class from having multiple instances by using constructors in Python? Provide an\n",
    "example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "1c610871-64b3-41e0-abfa-3748610870b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Second Instance\n",
      "Second Instance\n"
     ]
    }
   ],
   "source": [
    "#Preventing Multiple Instances in Python (Singleton Design Pattern):\n",
    "\n",
    "'''To prevent a class from having multiple instances, you can implement the Singleton Design Pattern. This ensures that only one instance of the class exists throughout the program.\n",
    "Using a Constructor to Enforce Singleton:'''\n",
    "\n",
    "'''In Python, the Singleton pattern can be implemented by overriding the class's instantiation process. One common way is to use a class-level variable to store the single instance.'''\n",
    "\n",
    "class Singleton:\n",
    "    _instance = None   \n",
    "\n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        if cls._instance is None:\n",
    "            cls._instance = super().__new__(cls) \n",
    "        return cls._instance  \n",
    "\n",
    "    def __init__(self, value):\n",
    "        self.value = value  \n",
    " \n",
    "obj1 = Singleton(\"First Instance\")\n",
    "obj2 = Singleton(\"Second Instance\")\n",
    "\n",
    " \n",
    "print(obj1 is obj2)   \n",
    "print(obj1.value)     \n",
    "print(obj2.value)    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ecfa269-c7f9-4b61-9f17-dcc47f0a7372",
   "metadata": {},
   "source": [
    "17. Create a Python class called `Student` with a constructor that takes a list of subjects as a parameter and\n",
    "initializes the `subjects` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "6809c26b-891d-4ada-a2d2-9d2c434c6f73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subjects: Math, Science, History\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, subjects):\n",
    "        self.subjects = subjects   \n",
    "    def display_subjects(self):\n",
    "        print(\"Subjects:\", \", \".join(self.subjects))\n",
    "student1 = Student([\"Math\", \"Science\", \"History\"])\n",
    "\n",
    "# Displaying the subjects\n",
    "student1.display_subjects()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10225d57-692d-4d73-9cf7-34c17179a692",
   "metadata": {},
   "source": [
    "18. What is the purpose of the `__del__` method in Python classes, and how does it relate to constructors?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0b691b0-9e5d-4498-844b-e30418ebd89f",
   "metadata": {},
   "source": [
    "The __del__ Method in Python Classes:\n",
    "\n",
    "    Definition: The __del__ method, also known as the destructor, is a special method in Python that is called when an object is about to be destroyed or garbage collected.\n",
    "    Purpose: It is used to define cleanup actions (e.g., releasing resources or closing files) that need to occur when an object is no longer in use.\n",
    "\n",
    "Relationship with Constructors:\n",
    "\n",
    "    Constructor (__init__): Initializes the object and sets up resources.\n",
    "    Destructor (__del__): Cleans up resources when the object is destroyed.\n",
    "    Together, they manage the lifecycle of an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "0dcb72a5-4b83-47e2-bade-b6bf791ed4c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File 'example.txt' opened.\n",
      "File 'example.txt' closed.\n"
     ]
    }
   ],
   "source": [
    "class FileHandler:\n",
    "    def __init__(self, file_name):\n",
    "        self.file_name = file_name\n",
    "        self.file = open(file_name, 'w')   \n",
    "        print(f\"File '{self.file_name}' opened.\")\n",
    "\n",
    "    def write(self, data):\n",
    "        self.file.write(data)\n",
    "\n",
    "    def __del__(self):\n",
    "        self.file.close()   \n",
    "        print(f\"File '{self.file_name}' closed.\")\n",
    "\n",
    "# Creating and using an object\n",
    "handler = FileHandler(\"example.txt\")\n",
    "handler.write(\"Hello, World!\")\n",
    "del handler  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aa1e9f2-9282-4421-9ddc-bd4875931b07",
   "metadata": {},
   "source": [
    "Q19. Explain the use of constructor chaining in Python. Provide a practical example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83a2e006-9a64-42bb-87b3-c9465ad56c25",
   "metadata": {},
   "source": [
    "Constructor Chaining in Python:\n",
    "\n",
    "Constructor chaining refers to the concept of calling a constructor of a parent class (superclass) from a constructor of a child class (subclass). This allows a subclass to reuse the initialization logic defined in the superclass constructor.\n",
    "How Constructor Chaining Works in Python:\n",
    "\n",
    "    It is achieved using the super() function within the subclass constructor.\n",
    "    The super() function calls the parent class’s __init__ method, ensuring that the parent’s attributes are initialized before adding the subclass-specific logic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "1ef9598b-b9e9-4ed2-afc4-0d7ceffe2033",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal constructor: Mammal\n",
      "Dog constructor: Golden Retriever\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, species):\n",
    "        self.species = species\n",
    "        print(f\"Animal constructor: {self.species}\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def __init__(self, species, breed):\n",
    "        super().__init__(species)   \n",
    "        self.breed = breed\n",
    "        print(f\"Dog constructor: {self.breed}\")\n",
    "\n",
    " \n",
    "dog1 = Dog(\"Mammal\", \"Golden Retriever\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1a2594a-c61e-482e-b0f2-8ed4b6b035ce",
   "metadata": {},
   "source": [
    "Q20. Create a Python class called `Car` with a default constructor that initializes the `make` and `model`\n",
    "attributes. Provide a method to display car information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "9749359b-c6f8-4651-a682-1d3e109a558c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car Make: THAR\n",
      "Car Model: SCORPIO\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    def __init__(self):  \n",
    "        self.make = \"THAR\"  \n",
    "        self.model = \"SCORPIO\"   \n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Car Make: {self.make}\")\n",
    "        print(f\"Car Model: {self.model}\")\n",
    " \n",
    "car1 = Car()\n",
    " \n",
    "car1.display_info()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3082dd84-3b35-47a4-a2b3-bd887df38757",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1fb24720-556a-4658-af12-9aa0a183bc19",
   "metadata": {},
   "source": [
    "                                                                 Inheritance:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eec6ba9-953e-489f-b4e4-7dc344d18142",
   "metadata": {},
   "source": [
    "Q1. What is inheritance in Python? Explain its significance in object-oriented programming."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1b252cf-a94e-48a8-9945-48d26630ee84",
   "metadata": {},
   "source": [
    "Inheritance in Python:\n",
    "\n",
    "    Definition: Inheritance is an object-oriented programming (OOP) concept where a class (child class) derives properties and behaviors (attributes and methods) from another class (parent class).\n",
    "    Purpose: It promotes code reuse, extensibility, and the ability to create hierarchical relationships between classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "33affac3-dc8b-40b1-a61d-db2ebf734d3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some generic sound\n",
      "Bark\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, species):\n",
    "        self.species = species\n",
    "\n",
    "    def sound(self):\n",
    "        return \"Some generic sound\"\n",
    "\n",
    "class Dog(Animal):  \n",
    "    def __init__(self, species, breed):\n",
    "        super().__init__(species)\n",
    "        self.breed = breed\n",
    "\n",
    "    def sound(self):   \n",
    "        return \"Bark\"\n",
    "\n",
    "# Creating objects\n",
    "animal = Animal(\"Generic Animal\")\n",
    "dog = Dog(\"Mammal\", \"Labrador\")\n",
    "\n",
    "print(animal.sound())   \n",
    "print(dog.sound())      "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58054bf2-8e46-4442-b7e0-e88ed31c3f35",
   "metadata": {},
   "source": [
    "2. Differentiate between single inheritance and multiple inheritance in Python. Provide examples for each."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a021a89b-c50e-4934-964c-d13715efeb20",
   "metadata": {},
   "source": [
    "Single Inheritance\t\n",
    "\n",
    "Definitio-\tA class inherits from one parent class.\t\n",
    "Hierarchy-\tSimple, linear inheritance hierarchy.\t\n",
    "Code Reusability-\tInherits features from a single class.\t\n",
    "Conflict Resolution-\tNo ambiguity in method resolution.\t\n",
    "Complexity- Easier to implement and understand.\t\n",
    "\n",
    "Multiple Inheritance\n",
    "    \n",
    "Definitio-\tA class inherits from two or more parent classes.\n",
    "Hierarchy- More complex, with multiple parent classes.\n",
    "Code Reusability- Combines features from multiple classes.\n",
    "Conflict Resolution- Potential for conflicts; resolved by the Method Resolution Order (MRO).\n",
    "Complexity- Requires careful design to avoid conflicts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "986e3e9f-5ae5-4b5a-8bbe-7780483ac798",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bark\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def sound(self):\n",
    "        return \"Some generic sound\"\n",
    "\n",
    "class Dog(Animal):  \n",
    "    def sound(self):  \n",
    "        return \"Bark\"\n",
    " \n",
    "dog = Dog()\n",
    "print(dog.sound())   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99258e58-df3b-4091-9670-6aa35c8bae8a",
   "metadata": {},
   "source": [
    "Q3. Create a Python class called `Vehicle` with attributes `color` and `speed`. Then, create a child class called\n",
    "`Car` that inherits from `Vehicle` and adds a `brand` attribute. Provide an example of creating a `Car` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "8a620ade-aa6a-4ab9-a738-598c9ae5c1cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Brand: Toyota, Color: Red, Speed: 150 km/h\n"
     ]
    }
   ],
   "source": [
    "# Parent class\n",
    "class Vehicle:\n",
    "    def __init__(self, color, speed):\n",
    "        self.color = color\n",
    "        self.speed = speed\n",
    "\n",
    "# Child class\n",
    "class Car(Vehicle):\n",
    "    def __init__(self, color, speed, brand):\n",
    "        super().__init__(color, speed)  \n",
    "        self.brand = brand             \n",
    "\n",
    "    def display_details(self):\n",
    "        print(f\"Brand: {self.brand}, Color: {self.color}, Speed: {self.speed} km/h\")\n",
    " \n",
    "my_car = Car(\"Red\", 150, \"Toyota\")\n",
    "my_car.display_details()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d96e4841-fb0d-4b13-82b8-7ffe2ea90506",
   "metadata": {},
   "source": [
    "4. Explain the concept of method overriding in inheritance. Provide a practical example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f727a400-fa79-47f1-9c4a-db3dba53f738",
   "metadata": {},
   "source": [
    "Method Overriding in Inheritance:\n",
    "\n",
    "    Definition: Method overriding occurs when a subclass provides a specific implementation of a method already defined in its parent class. The subclass method replaces the parent class method when called through an instance of the subclass.\n",
    "\n",
    "    Purpose:\n",
    "        Customize or extend the behavior of the parent class.\n",
    "        Enable polymorphism, where the same method name can behave differently depending on the class of the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "c18ee4cc-164c-4366-aed4-a2e5ee5e7290",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some generic animal sound\n",
      "Bark\n",
      "Meow\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def sound(self):\n",
    "        return \"Some generic animal sound\"\n",
    "\n",
    "class Dog(Animal):\n",
    "    def sound(self):  # Overriding the sound method\n",
    "        return \"Bark\"\n",
    "\n",
    "class Cat(Animal):\n",
    "    def sound(self):  # Overriding the sound method\n",
    "        return \"Meow\"\n",
    "\n",
    "# Creating objects\n",
    "animal = Animal()\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "# Calling the sound method\n",
    "print(animal.sound())  # Output: Some generic animal sound\n",
    "print(dog.sound())     # Output: Bark\n",
    "print(cat.sound())     # Output: Meow\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9da3cdcd-3880-4f76-b5a5-8c727b0cc74a",
   "metadata": {},
   "source": [
    "Q5. How can you access the methods and attributes of a parent class from a child class in Python? Give an\n",
    "example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40db2c25-5f26-44a9-a9ee-37f834c0fd00",
   "metadata": {},
   "source": [
    "Accessing Parent Class Methods and Attributes from a Child Class in Python:\n",
    "\n",
    "You can access the parent class's methods and attributes in a child class using:\n",
    "\n",
    "    super():\n",
    "        A built-in function that allows you to call methods and access attributes of the parent class.\n",
    "        Typically used in the child's methods (e.g., __init__) to initialize or extend parent functionality.\n",
    "\n",
    "    Using the Parent Class Name:\n",
    "        Directly calling the parent class’s method using ParentClass.method(self, ...)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "4c9005c7-5187-4d22-ae3f-41019dcca4a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vehicle Color: Red, Speed: 150 km/h\n",
      "Car Brand: Toyota\n"
     ]
    }
   ],
   "source": [
    "class Vehicle:\n",
    "    def __init__(self, color, speed):\n",
    "        self.color = color\n",
    "        self.speed = speed\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Vehicle Color: {self.color}, Speed: {self.speed} km/h\")\n",
    "\n",
    "class Car(Vehicle):\n",
    "    def __init__(self, color, speed, brand):\n",
    "        super().__init__(color, speed)  # Initialize parent class attributes\n",
    "        self.brand = brand             # Add child-specific attribute\n",
    "\n",
    "    def display_info(self):\n",
    "        super().display_info()  # Call the parent class method\n",
    "        print(f\"Car Brand: {self.brand}\")\n",
    "\n",
    "# Creating a Car object\n",
    "car = Car(\"Red\", 150, \"Toyota\")\n",
    "car.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39b8d969-d6e3-4095-b22d-a7c284390b78",
   "metadata": {},
   "source": [
    "Q6. Discuss the use of the `super()` function in Python inheritance. When and why is it used? Provide an\n",
    "example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef0d1a43-f46e-4a09-b723-b94771fcb650",
   "metadata": {},
   "source": [
    "The super() Function in Python Inheritance\n",
    "\n",
    "The super() function in Python is used to call methods from a parent (or superclass) within a child (or subclass) class. It is particularly useful in inheritance when you want to:\n",
    "\n",
    "    Call a method from the parent class: This allows the child class to extend or modify the behavior of the parent class method.\n",
    "    Ensure correct method resolution order (MRO): super() respects the class hierarchy and method resolution order, making it useful in multiple inheritance scenarios.\n",
    "    Avoid directly referencing parent class names: It helps to maintain code flexibility and readability, as you don’t need to explicitly name the parent class.\n",
    "\n",
    "When and Why to Use super():\n",
    "\n",
    "    Initialization in child classes: Often used in the child class constructor to initialize the parent class.\n",
    "    Multiple Inheritance: Ensures the correct method is called from the proper class in a multiple inheritance chain.\n",
    "    Avoiding repetition: It allows for reusing parent class methods and logic without duplicating code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "7ba24c49-60eb-44ff-83d0-a5acc114ab11",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Mammal makes a sound.\n",
      "The Golden Retriever dog barks.\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, species):\n",
    "        self.species = species\n",
    "\n",
    "    def speak(self):\n",
    "        print(f\"The {self.species} makes a sound.\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def __init__(self, species, breed):\n",
    "        super().__init__(species)  # Calls the parent class constructor\n",
    "        self.breed = breed\n",
    "\n",
    "    def speak(self):\n",
    "        super().speak()  # Calls the parent class method\n",
    "        print(f\"The {self.breed} dog barks.\")\n",
    "\n",
    "# Creating a Dog object\n",
    "dog = Dog(\"Mammal\", \"Golden Retriever\")\n",
    "dog.speak()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec59166d-05e8-482c-8162-856984d240f8",
   "metadata": {},
   "source": [
    "Q7. Create a Python class called `Animal` with a method `speak()`. Then, create child classes `Dog` and `Cat`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "5b8b3d6e-f5b3-4edd-910d-6abf86129913",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dog barks.\n",
      "The cat meows.\n"
     ]
    }
   ],
   "source": [
    "# Parent class\n",
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"The animal makes a sound.\")\n",
    "\n",
    "# Child class Dog inheriting from Animal\n",
    "class Dog(Animal):\n",
    "    def speak(self):  # Overriding the speak method\n",
    "        print(\"The dog barks.\")\n",
    "\n",
    "# Child class Cat inheriting from Animal\n",
    "class Cat(Animal):\n",
    "    def speak(self):  # Overriding the speak method\n",
    "        print(\"The cat meows.\")\n",
    "\n",
    "# Creating objects of Dog and Cat\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "# Calling the speak method on both objects\n",
    "dog.speak()  # Output: The dog barks.\n",
    "cat.speak()  # Output: The cat meows.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22e416de-aeea-4cd6-8224-da4af9b2dfd9",
   "metadata": {},
   "source": [
    "8. Explain the role of the `isinstance()` function in Python and how it relates to inheritance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "229da09b-0027-48ee-b434-ecec801c44bb",
   "metadata": {},
   "source": [
    "isinstance() Function in Python\n",
    "\n",
    "The isinstance() function is used to check whether an object is an instance of a specified class or a subclass thereof. This function is particularly useful in object-oriented programming (OOP) to verify the type of an object at runtime, especially when dealing with inheritance.\n",
    "\n",
    "How isinstance() Relates to Inheritance:\n",
    "\n",
    "    In the context of inheritance, isinstance() checks if an object is an instance of the given class or any class in its inheritance chain.\n",
    "    This is especially useful when working with polymorphism or when you need to ensure an object belongs to a certain type, including its subclasses."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9830c802-046e-4469-b463-a40f768dbc6e",
   "metadata": {},
   "source": [
    "Q9. Create a Python class called Animal with a method speak(). Then, create child classes Dog and Cat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "71e62a2e-f692-4cee-8553-8d9450b4c14d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The dog barks.\n",
      "The cat meows.\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"The animal makes a sound.\")\n",
    " \n",
    "class Dog(Animal):\n",
    "    def speak(self):   \n",
    "        print(\"The dog barks.\")\n",
    " \n",
    "class Cat(Animal):\n",
    "    def speak(self):  \n",
    "        print(\"The cat meows.\")\n",
    " \n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    " \n",
    "dog.speak() \n",
    "cat.speak()  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22740617-39c4-416c-af6f-a7194384646e",
   "metadata": {},
   "source": [
    "Q11. Create a Python class called `Shape` with a method `area()` that calculates the area of a shape. Then, create child classes `Circle` and `Rectangle` that inherit from `Shape` and implement the `area()` method\n",
    "accordingly. Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "19129859-eb42-4c40-ab66-e9c1ccb64204",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the Circle: 78.54\n",
      "Area of the Rectangle: 24\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# Parent class\n",
    "class Shape:\n",
    "    def area(self):\n",
    "        raise NotImplementedError(\"Subclasses must implement this method\")\n",
    "\n",
    "# Child class Circle inheriting from Shape\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return math.pi * self.radius ** 2  # Area of a circle: πr²\n",
    "\n",
    "# Child class Rectangle inheriting from Shape\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  # Area of a rectangle: width * height\n",
    "\n",
    "# Creating objects of Circle and Rectangle\n",
    "circle = Circle(5)  # Circle with radius 5\n",
    "rectangle = Rectangle(4, 6)  # Rectangle with width 4 and height 6\n",
    "\n",
    "# Calling the area method on both objects\n",
    "print(f\"Area of the Circle: {circle.area():.2f}\")  # Output: Area of the Circle: 78.54\n",
    "print(f\"Area of the Rectangle: {rectangle.area()}\")  # Output: Area of the Rectangle: 24\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "788049cc-2b52-410a-be42-e5791237d700",
   "metadata": {},
   "source": [
    "Q13. How can you prevent a child class from modifying certain attributes or methods inherited from a parent\n",
    "class in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "cdeb71c7-062d-447c-b40e-caed339e0b57",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parent:\n",
    "    def __init__(self):\n",
    "        self.__private_attr = 10\n",
    "\n",
    "    def __private_method(self):\n",
    "        print(\"This is a private method.\")\n",
    "\n",
    "class Child(Parent):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        # self.__private_attr cannot be accessed directly in Child\n",
    "        # self.__private_method() cannot be called directly in Child\n",
    "        \n",
    "# Creating object of Child\n",
    "child = Child()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53144cfb-1eac-4ed9-a422-73215b2c90e2",
   "metadata": {},
   "source": [
    "15. Discuss the concept of method overloading in Python inheritance. How does it differ from method\n",
    "overriding?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce2aa0a3-aca6-4606-a060-a5810bc889ee",
   "metadata": {},
   "source": [
    "Method Overriding in Python Inheritance\n",
    "\n",
    "Method Overriding is a feature of object-oriented programming where a child class provides its specific implementation of a method that is already defined in the parent class. When a method in the child class has the same name and signature as a method in the parent class, the child class’s method overrides the parent class’s method.\n",
    "\n",
    "This allows a subclass to change or extend the behavior of the inherited method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "235fd54f-f09f-41bb-963c-4a99ed41d9a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some generic sound\n",
      "Bark\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def sound(self):\n",
    "        print(\"Some generic sound\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def sound(self):\n",
    "        print(\"Bark\")\n",
    "\n",
    "# Creating objects\n",
    "animal = Animal()\n",
    "dog = Dog()\n",
    "\n",
    "animal.sound()  # Output: Some generic sound\n",
    "dog.sound()     # Output: Bark\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c5bb670-83b0-41b6-80cb-0f3e964acdd3",
   "metadata": {},
   "source": [
    "Q16. Explain the purpose of the `__init__()` method in Python inheritance and how it is utilized in child classes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5532e71e-228a-4493-81f7-fc35796fe468",
   "metadata": {},
   "source": [
    "Purpose of the __init__() Method in Python Inheritance\n",
    "\n",
    "The __init__() method in Python is the constructor of a class. It is automatically called when an object is created from the class. In Python inheritance, the __init__() method plays a crucial role in initializing the attributes of both parent and child classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "9072b6c6-a043-4978-b2cb-7634ae1651aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Buddy, Age: 3\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "class Dog(Animal):\n",
    "    pass  # No __init__ method in Dog, so it inherits from Animal\n",
    "\n",
    "# Creating an object of Dog\n",
    "dog = Dog(\"Buddy\", 3)\n",
    "\n",
    "# Accessing attributes\n",
    "print(f\"Name: {dog.name}, Age: {dog.age}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d26b8d4a-8e1a-42a6-abe8-8b590b446a05",
   "metadata": {},
   "source": [
    "Q17. Create a Python class called `Bird` with a method `fly()`. Then, create child classes `Eagle` and `Sparrow` that inherit from `Bird` and implement the `fly()` method differently. Provide an example of using these\n",
    "classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "e7f6e5cd-de4b-49f7-90b9-5a949456d78a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eagle soars high in the sky.\n",
      "Sparrow flies swiftly.\n"
     ]
    }
   ],
   "source": [
    "# Parent class Bird\n",
    "class Bird:\n",
    "    def fly(self):\n",
    "        print(\"Bird is flying.\")\n",
    "\n",
    "# Child class Eagle\n",
    "class Eagle(Bird):\n",
    "    def fly(self):\n",
    "        print(\"Eagle soars high in the sky.\")\n",
    "\n",
    "# Child class Sparrow\n",
    "class Sparrow(Bird):\n",
    "    def fly(self):\n",
    "        print(\"Sparrow flies swiftly.\")\n",
    "\n",
    "# Creating objects of Eagle and Sparrow\n",
    "eagle = Eagle()\n",
    "sparrow = Sparrow()\n",
    "\n",
    "# Calling the fly method on each object\n",
    "eagle.fly()    # Output: Eagle soars high in the sky.\n",
    "sparrow.fly()  # Output: Sparrow flies swiftly.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2dc4bce-09a2-4ac4-8771-9ae0b1bebd36",
   "metadata": {},
   "source": [
    "Q18. What is the \"diamond problem\" in multiple inheritance, and how does Python address it?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e05915c5-d8e0-4e7f-8bb1-344e5d063c95",
   "metadata": {},
   "source": [
    "The Diamond Problem in Multiple Inheritance\n",
    "\n",
    "The diamond problem occurs in object-oriented programming when a class inherits from two classes that both inherit from a common base class. This creates a \"diamond\" shape in the class hierarchy. The problem arises when there is ambiguity about which version of a method or attribute should be inherited by the child class, particularly if the methods or attributes in the parent classes have different implementations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "df57a507-6b4b-4eff-af10-fcf3641d909a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method from class B\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def show(self):\n",
    "        print(\"Method from class A\")\n",
    "\n",
    "class B(A):\n",
    "    def show(self):\n",
    "        print(\"Method from class B\")\n",
    "\n",
    "class C(A):\n",
    "    def show(self):\n",
    "        print(\"Method from class C\")\n",
    "\n",
    "class D(B, C):\n",
    "    pass\n",
    "\n",
    "# Creating an object of class D\n",
    "d = D()\n",
    "d.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e21a8fdf-5d96-441f-a962-aec7114ff240",
   "metadata": {},
   "source": [
    "Q19. Discuss the concept of \"is-a\" and \"has-a\" relationships in inheritance, and provide examples of each."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d8114c0-e40a-4810-a64e-97152149ff3c",
   "metadata": {},
   "source": [
    "\"Is-a\" and \"Has-a\" Relationships in Inheritance\n",
    "\n",
    "In object-oriented programming, \"is-a\" and \"has-a\" are two fundamental relationships that describe how classes relate to each other in terms of inheritance and composition. These relationships help to clarify the design and intent behind class structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "id": "f1f45ade-4aab-47b4-9100-1bb078fb4d2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal makes a sound\n",
      "Dog barks\n",
      "True\n",
      "Car is driving\n",
      "Engine starts\n"
     ]
    }
   ],
   "source": [
    "'''1. \"Is-a\" Relationship (Inheritance)\n",
    "\n",
    "The \"is-a\" relationship is used to describe an inheritance relationship, where a child class is a specialized version of a parent class.\n",
    "This means that an object of the child class can be treated as an object of the parent class because it inherits from the parent.'''\n",
    "\n",
    "\n",
    "# Parent class\n",
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Animal makes a sound\")\n",
    "\n",
    "# Child class\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Dog barks\")\n",
    "\n",
    "# Creating objects\n",
    "animal = Animal()\n",
    "dog = Dog()\n",
    "\n",
    "# Method calls\n",
    "animal.speak()  # Output: Animal makes a sound\n",
    "dog.speak()     # Output: Dog barks\n",
    "\n",
    "# Dog is an Animal\n",
    "print(isinstance(dog, Animal))  # Output: True\n",
    "\n",
    "\n",
    "'''2. \"Has-a\" Relationship (Composition)\n",
    "\n",
    "The \"has-a\" relationship describes composition, where one class has an instance of another class as an attribute. In this case,one object contains or \n",
    "is composed of other objects, but the contained objects don't necessarily share the same characteristics or behavior as the container class.'''\n",
    "\n",
    "# Class representing Engine\n",
    "class Engine:\n",
    "    def start(self):\n",
    "        print(\"Engine starts\")\n",
    "\n",
    "# Class representing Car\n",
    "class Car:\n",
    "    def __init__(self, engine):\n",
    "        self.engine = engine  # Car has an Engine\n",
    "\n",
    "    def drive(self):\n",
    "        print(\"Car is driving\")\n",
    "        self.engine.start()\n",
    "\n",
    "# Creating objects\n",
    "engine = Engine()\n",
    "car = Car(engine)\n",
    "\n",
    "# Method calls\n",
    "car.drive()  # Output: Car is driving, Engine starts\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5962a1d7-ef79-4c74-b5e6-48b1aa8c9cd5",
   "metadata": {},
   "source": [
    "20. Create a Python class hierarchy for a university system. Start with a base class `Person` and create child\n",
    "classes `Student` and `Professor`, each with their own attributes and methods. Provide an example of using\n",
    "these classes in a university context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "id": "f1ed43aa-17f3-49a4-90be-410f27a7bc2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student Information:\n",
      "Name: Alice Johnson\n",
      "Age: 20\n",
      "Address: 123 Main St\n",
      "Student ID: S12345\n",
      "Major: Computer Science\n",
      "Alice Johnson is studying for their Computer Science major.\n",
      "\n",
      "Professor Information:\n",
      "Name: Dr. John Smith\n",
      "Age: 45\n",
      "Address: 456 University Ave\n",
      "Professor ID: P98765\n",
      "Department: Physics\n",
      "Dr. John Smith is teaching in the Physics department.\n"
     ]
    }
   ],
   "source": [
    "# Base class Person\n",
    "class Person:\n",
    "    def __init__(self, name, age, address):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.address = address\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}\")\n",
    "        print(f\"Age: {self.age}\")\n",
    "        print(f\"Address: {self.address}\")\n",
    "\n",
    "# Child class Student\n",
    "class Student(Person):\n",
    "    def __init__(self, name, age, address, student_id, major):\n",
    "        super().__init__(name, age, address)  # Call the constructor of the base class\n",
    "        self.student_id = student_id\n",
    "        self.major = major\n",
    "\n",
    "    def display_student_info(self):\n",
    "        self.display_info()  # Call base class method to display common info\n",
    "        print(f\"Student ID: {self.student_id}\")\n",
    "        print(f\"Major: {self.major}\")\n",
    "\n",
    "    def study(self):\n",
    "        print(f\"{self.name} is studying for their {self.major} major.\")\n",
    "\n",
    "# Child class Professor\n",
    "class Professor(Person):\n",
    "    def __init__(self, name, age, address, professor_id, department):\n",
    "        super().__init__(name, age, address)  # Call the constructor of the base class\n",
    "        self.professor_id = professor_id\n",
    "        self.department = department\n",
    "\n",
    "    def display_professor_info(self):\n",
    "        self.display_info()  # Call base class method to display common info\n",
    "        print(f\"Professor ID: {self.professor_id}\")\n",
    "        print(f\"Department: {self.department}\")\n",
    "\n",
    "    def teach(self):\n",
    "        print(f\"{self.name} is teaching in the {self.department} department.\")\n",
    "\n",
    "# Example usage:\n",
    "\n",
    "# Creating Student and Professor objects\n",
    "student1 = Student(\"Alice Johnson\", 20, \"123 Main St\", \"S12345\", \"Computer Science\")\n",
    "professor1 = Professor(\"Dr. John Smith\", 45, \"456 University Ave\", \"P98765\", \"Physics\")\n",
    "\n",
    "# Displaying their information\n",
    "print(\"Student Information:\")\n",
    "student1.display_student_info()\n",
    "student1.study()  # Student behavior\n",
    "\n",
    "print(\"\\nProfessor Information:\")\n",
    "professor1.display_professor_info()\n",
    "professor1.teach()  # Professor behavior\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c0ccadb-a1e7-4656-87b1-41d8fa5824d7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f8d25690-45c5-40af-b18e-58ad191a5a91",
   "metadata": {},
   "source": [
    "                                                            Encapsulation:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a99e133-95fc-4737-a8c2-7668b6bbce43",
   "metadata": {},
   "source": [
    "Q1. Explain the concept of encapsulation in Python. What is its role in object-oriented programming?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8597b6fc-d6b0-4889-aa66-566a3c3e35a8",
   "metadata": {},
   "source": [
    "Encapsulation in Python\n",
    "\n",
    "Encapsulation is one of the fundamental principles of object-oriented programming (OOP). It refers to the concept of bundling data (attributes) and methods (functions) that operate on the data within a single unit, or class, and restricting access to certain components of that class. This helps in hiding the internal details of the object and only exposing what is necessary for the outside world.\n",
    "Role in Object-Oriented Programming\n",
    "\n",
    "In OOP, encapsulation provides several important benefits:\n",
    "\n",
    "    Data Hiding:\n",
    "        Encapsulation allows you to hide the internal state of an object from the outside world, only exposing necessary functionality. This prevents direct modification of object attributes, ensuring that data is accessed and modified through well-defined methods.\n",
    "\n",
    "    Modularity:\n",
    "        By bundling related data and methods together in a class, encapsulation promotes a modular approach. Each class can be considered a self-contained unit, making it easier to manage, test, and maintain.\n",
    "\n",
    "    Control and Protection:\n",
    "        Through encapsulation, a class can control how its attributes are accessed or modified, protecting the integrity of the data and ensuring that certain rules or validations are followed.\n",
    "\n",
    "    Flexibility and Maintenance:\n",
    "        Encapsulation provides the flexibility to change the internal implementation of a class without affecting other parts of the program. For example, you can change how data is stored or how methods work without changing the interface (the way other parts of the program interact with the object)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bed88860-a04f-47b8-ba49-b597d0db0938",
   "metadata": {},
   "source": [
    "Q2. Describe the key principles of encapsulation, including access control and data hiding."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f38e3fdb-61b4-47f5-9fda-c308c24a8244",
   "metadata": {},
   "source": [
    "Key Principles of Encapsulation in Python\n",
    "\n",
    "Encapsulation is a fundamental concept in object-oriented programming (OOP) that involves restricting access to certain components of an object and controlling how data is accessed and modified. There are two primary principles of encapsulation: access control and data hiding.\n",
    "\n",
    "1. Access Control\n",
    "\n",
    "    Access control refers to restricting or controlling access to the attributes and methods of a class. This ensures that the internal state of an         object can only be accessed or modified through well-defined interfaces, typically through methods or functions.\n",
    "\n",
    "In Python, access control is implemented through the use of access specifiers or modifiers:\n",
    "\n",
    "    Public Members: These are attributes or methods that are accessible from outside the class. By default, all members of a class are public.\n",
    "\n",
    "    Protected Members: These are attributes or methods that are intended for internal use within the class or its subclasses. They are indicated by a single underscore (_) before the attribute or method name. While not strictly enforced in Python, it signals to developers that these members should not be accessed directly.\n",
    "\n",
    "    Private Members: These are attributes or methods that should not be accessed directly from outside the class. They are marked with a double underscore (__) before the attribute or method name. Python uses name mangling to make these attributes less accessible (though still technically accessible by a modified name). The purpose is to protect data and prevent accidental modification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "id": "b8e82e99-9d59-47ed-a7ca-c7f5e81854f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice\n",
      "Unknown\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name          # Public attribute\n",
    "        self._address = \"Unknown\" # Protected attribute\n",
    "        self.__age = age          # Private attribute\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}\")\n",
    "        print(f\"Address: {self._address}\")\n",
    "        print(f\"Age: {self.__age}\")\n",
    " \n",
    "person = Person(\"Alice\", 30)\n",
    "print(person.name)  \n",
    "print(person._address)  \n",
    "\n",
    "print(person._Person__age)   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0e9ab1f-2211-4e0e-8037-89cb4cb70760",
   "metadata": {},
   "source": [
    "Q3. How do you define a constructor in a Python class? Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "id": "e7dfe86a-9112-460d-b3c1-687f2abdeb72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Alice\n",
      "Age: 30\n"
     ]
    }
   ],
   "source": [
    "'''Defining a Constructor in a Python Class\n",
    "\n",
    "In Python, a constructor is a special method that is automatically called when an object is created from a class.The constructoris used to \n",
    "initialize the attributes (properties) of the object.\n",
    "The constructor method in Python is called __init__(). It is not explicitly called when creating an object,but is invoked automatically \n",
    "when an instance of the class is created.'''\n",
    "\n",
    "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}\")\n",
    "        print(f\"Age: {self.age}\")\n",
    " \n",
    "person1 = Person(\"Alice\", 30)\n",
    " \n",
    "person1.display_info()  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a91d90ab-9cc8-44a9-bea8-6d43045595fc",
   "metadata": {},
   "source": [
    "Q4. Explain the `__init__` method in Python and its role in constructors."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7eb9873-e5de-44fd-84c4-015ca7f60e7c",
   "metadata": {},
   "source": [
    "The __init__ Method in Python\n",
    "\n",
    "The __init__ method in Python is a special method used to initialize newly created objects of a class. It is often referred to as the constructor in Python, though technically it's a method used to initialize the object's state. When a new object is created, the __init__ method is automatically called, and its primary role is to assign values to the object’s attributes and set up any necessary state.\n",
    "Role of __init__ in Constructors:\n",
    "\n",
    "    Object Initialization:\n",
    "        The __init__ method initializes the object’s attributes with values when an object is created. Without __init__, the object would not be set up with its initial state and would have to be manually initialized later.\n",
    "\n",
    "    Automatic Invocation:\n",
    "        The __init__ method is called automatically when a new object is created. The arguments passed during object creation are passed to the __init__ method.\n",
    "\n",
    "    Encapsulation:\n",
    "        It helps in encapsulating the data inside the object and ensures that objects are initialized in a consistent manner."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "383d1114-4da7-45f4-b838-543d256d1901",
   "metadata": {},
   "source": [
    "Q5. In a class named `Person`, create a constructor that initializes the `name` and `age` attributes. Provide an\n",
    "example of creating an object of this class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "id": "0d10c978-0b01-48f4-9acb-28f39764a5d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amit\n",
      "Agra\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name          # Public attribute\n",
    "        self._address = \"Agra\" # Protected attribute\n",
    "        self.__age = age          # Private attribute\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}\")\n",
    "        print(f\"Address: {self._address}\")\n",
    "        print(f\"Age: {self.__age}\")\n",
    " \n",
    "person = Person(\"Amit\", 28)\n",
    "print(person.name)  \n",
    "print(person._address)  \n",
    "\n",
    "print(person._Person__age)   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d070204-c48e-43f0-a524-e7b95b6e8508",
   "metadata": {},
   "source": [
    "Q6. How can you call a constructor explicitly in Python? Give an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bbbb3ba-22fd-4aa2-bc40-878eee5c7e89",
   "metadata": {},
   "source": [
    " In Python, constructors are typically called implicitly when an object is instantiated. However, it is possible to call a constructor explicitly using the __init__ method, though it's generally not recommended. This is useful in certain scenarios, such as when you want to reinitialize an object or when dealing with multiple inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "id": "5c71b390-8f91-4294-93af-dfb4e7e0861a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car Created: Toyota Corolla\n",
      "Make: Toyota, Model: Corolla\n",
      "Car Created: Honda Civic\n",
      "Make: Honda, Model: Civic\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    def __init__(self, make, model):\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        print(f\"Car Created: {self.make} {self.model}\")\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Make: {self.make}, Model: {self.model}\")\n",
    "\n",
    "\n",
    "# Create an object of the Car class\n",
    "car1 = Car(\"Toyota\", \"Corolla\")  # Constructor is called implicitly here\n",
    "car1.display_info()\n",
    "\n",
    "# Explicitly calling the constructor again to reinitialize the object\n",
    "car1.__init__(\"Honda\", \"Civic\")  # Explicitly calling the constructor\n",
    "car1.display_info()  # Output after reinitialization\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93fdc50f-e3d5-4470-9706-59abbb5d56bc",
   "metadata": {},
   "source": [
    "Q7. What is the significance of the `self` parameter in Python constructors? Explain with an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eefd7b0d-73bc-4f80-bbcc-7cac4cce788d",
   "metadata": {},
   "source": [
    "Significance of the self Parameter in Python Constructors\n",
    "\n",
    "The self parameter in Python constructors refers to the current instance of the class. It is used to access the attributes and methods of the class and to associate values passed during object creation with the instance attributes.\n",
    "Key Roles of self:\n",
    "\n",
    "    Instance Reference: It allows the constructor (__init__) to refer to the specific object being created.\n",
    "    Attribute Assignment: It helps in assigning values to instance attributes that belong to the object.\n",
    "    Distinguishing Between Instance and Local Variables: It ensures that attributes belong to the instance and are not confused with local variables or parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "id": "9b0784e9-e074-4e7b-a371-f05d84cc0022",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Alice\n",
      "Age: 30\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name  # Assign the value of 'name' to the instance attribute 'self.name'\n",
    "        self.age = age    # Assign the value of 'age' to the instance attribute 'self.age'\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}\")\n",
    "        print(f\"Age: {self.age}\")\n",
    "\n",
    "# Creating an instance of the Person class\n",
    "person1 = Person(\"Alice\", 30)\n",
    "\n",
    "# Accessing instance attributes and methods\n",
    "person1.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "137d03c8-9a90-4a79-8cc5-3ffe431fd137",
   "metadata": {},
   "source": [
    "Q8. Discuss the concept of default constructors in Python. When are they used?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5a653fd-87f5-433a-a468-449c168438ed",
   "metadata": {},
   "source": [
    "Default Constructors in Python\n",
    "\n",
    "A default constructor in Python is a constructor that does not take any arguments other than self. It is used to initialize an object with default values when no specific arguments are provided during object creation.\n",
    "Characteristics of Default Constructors:\n",
    "\n",
    "    No Parameters: It does not accept any additional arguments apart from self.\n",
    "    Implicit Initialization: Attributes are initialized to default values, which are typically hardcoded or set within the constructor.\n",
    "    Usage: Default constructors are useful when the object needs to be created with the same initial state every time or when specific arguments are not required."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b337bca-b9e6-47a9-9158-5c3ace75b368",
   "metadata": {},
   "source": [
    "Q9. Create a Python class called `Rectangle` with a constructor that initializes the `width` and `height`\n",
    "attributes. Provide a method to calculate the area of the rectangle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "id": "6e4190d5-f9cb-4e50-8e6d-7f4034acc9d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area of the rectangle is: 50\n"
     ]
    }
   ],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width  # Initialize the 'width' attribute\n",
    "        self.height = height  # Initialize the 'height' attribute\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return self.width * self.height  # Formula for area of a rectangle\n",
    "\n",
    "# Example usage\n",
    "rect = Rectangle(5, 10)  # Create a Rectangle object with width=5 and height=10\n",
    "area = rect.calculate_area()  # Calculate the area\n",
    "print(f\"The area of the rectangle is: {area}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6fdbd1f-d234-4277-9c77-73989d243363",
   "metadata": {},
   "source": [
    "Q10. How can you have multiple constructors in a Python class? Explain with an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "id": "b2475e13-a4d8-4962-b11f-5c93c5634eca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Unknown, Age: 0\n",
      "Name: Alice, Age: 0\n",
      "Name: Bob, Age: 25\n"
     ]
    }
   ],
   "source": [
    "# Method 1: Using Default Arguments\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name=\"Unknown\", age=0):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}, Age: {self.age}\")\n",
    "\n",
    "# Using the constructor with different argument patterns\n",
    "person1 = Person()  # Default constructor\n",
    "person2 = Person(\"Alice\")  # Constructor with only 'name'\n",
    "person3 = Person(\"Bob\", 25)  # Constructor with 'name' and 'age'\n",
    "\n",
    "person1.display_info()  # Output: Name: Unknown, Age: 0\n",
    "person2.display_info()  # Output: Name: Alice, Age: 0\n",
    "person3.display_info()  # Output: Name: Bob, Age: 25\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "id": "9b9a806c-2c9a-4995-8fbf-dd14d6911dfd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rectangle Area: 50\n",
      "Square Area: 16\n"
     ]
    }
   ],
   "source": [
    "# Method 2: Using Class Methods as Alternative Constructors\n",
    "\n",
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    @classmethod\n",
    "    def from_square(cls, side_length):\n",
    "        return cls(side_length, side_length)  # Create a rectangle with equal sides\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "# Using the main constructor\n",
    "rect1 = Rectangle(5, 10)\n",
    "\n",
    "# Using an alternative constructor\n",
    "square = Rectangle.from_square(4)\n",
    "\n",
    "print(f\"Rectangle Area: {rect1.calculate_area()}\")  # Output: 50\n",
    "print(f\"Square Area: {square.calculate_area()}\")    # Output: 16\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "838df80b-66bc-4351-8d25-6d40e1909a99",
   "metadata": {},
   "source": [
    "Q11. What is method overloading, and how is it related to constructors in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "id": "fe12e056-10ec-4a2f-8e96-45f07106e762",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Alice, Age: 25\n",
      "Name: Bob, Age: Unknown\n",
      "Name: Unknown, Age: Unknown\n"
     ]
    }
   ],
   "source": [
    "# Relation to Constructors in Python\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name=None, age=None):\n",
    "        if name is not None and age is not None:\n",
    "            self.name = name\n",
    "            self.age = age\n",
    "        elif name is not None:\n",
    "            self.name = name\n",
    "            self.age = \"Unknown\"\n",
    "        else:\n",
    "            self.name = \"Unknown\"\n",
    "            self.age = \"Unknown\"\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}, Age: {self.age}\")\n",
    " \n",
    "person1 = Person(\"Alice\", 25)   \n",
    "person2 = Person(\"Bob\")         \n",
    "person3 = Person()              \n",
    "\n",
    "person1.display_info()   \n",
    "person2.display_info()  \n",
    "person3.display_info()  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8004831-ada6-4dc8-98a8-2e920aa011b3",
   "metadata": {},
   "source": [
    "Q12. Explain the use of the `super()` function in Python constructors. Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "id": "37574dab-6ef1-4c7d-96af-b85f768f27ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Alice, Age: 30, Employee ID: E123\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "class Employee(Person):\n",
    "    def __init__(self, name, age, employee_id):\n",
    "        # Call the parent class constructor\n",
    "        super().__init__(name, age)\n",
    "        self.employee_id = employee_id\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}, Age: {self.age}, Employee ID: {self.employee_id}\")\n",
    "\n",
    "# Example usage\n",
    "emp = Employee(\"Alice\", 30, \"E123\")\n",
    "emp.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8436b72b-91fb-4032-9ffd-d42dbb5daffc",
   "metadata": {},
   "source": [
    "Q13. Create a class called `Book` with a constructor that initializes the `title`, `author`, and `published_year`\n",
    "attributes. Provide a method to display book details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "id": "c98c996c-298b-45dd-8c62-516a75879fe5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Title: To Kill a Mockingbird\n",
      "Author: Harper Lee\n",
      "Published Year: 1960\n",
      "\n",
      "Title: 1984\n",
      "Author: George Orwell\n",
      "Published Year: 1949\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author, published_year):\n",
    "        self.title = title   \n",
    "        self.author = author  \n",
    "        self.published_year = published_year   \n",
    "    def display_details(self):\n",
    "        print(f\"Title: {self.title}\")\n",
    "        print(f\"Author: {self.author}\")\n",
    "        print(f\"Published Year: {self.published_year}\")\n",
    " \n",
    "book1 = Book(\"To Kill a Mockingbird\", \"Harper Lee\", 1960)\n",
    "book2 = Book(\"1984\", \"George Orwell\", 1949)\n",
    "\n",
    "# Display book details\n",
    "book1.display_details()\n",
    "print()\n",
    "book2.display_details()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb1f4734-0e8a-4246-8f2c-6800f765b43c",
   "metadata": {},
   "source": [
    "Q14. Discuss the differences between constructors and regular methods in Python classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "id": "c2de81b4-d304-4535-ad23-91882d227094",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value is: 42\n"
     ]
    }
   ],
   "source": [
    "class Example:\n",
    "    def __init__(self, value):\n",
    "        # Constructor: Initializes object attributes\n",
    "        self.value = value\n",
    "\n",
    "    def display_value(self):\n",
    "        # Regular method: Performs an operation\n",
    "        print(f\"The value is: {self.value}\")\n",
    "\n",
    "# Creating an object\n",
    "obj = Example(42)  # Calls the constructor automatically\n",
    "\n",
    "# Calling a regular method\n",
    "obj.display_value()  # Explicitly calls the method\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ea22f67-ed04-45da-aa79-2965698da9d5",
   "metadata": {},
   "source": [
    "Q15. Explain the role of the `self` parameter in instance variable initialization within a constructor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7715c3b3-91e8-4ad6-a335-7bef6a8c0e23",
   "metadata": {},
   "source": [
    "Role of self in Instance Variable Initialization in a Constructor\n",
    "\n",
    "The self parameter in Python constructors (and instance methods) is a reference to the current instance of the class. It is used to:\n",
    "\n",
    "    Differentiate Between Instance and Local Variables:\n",
    "        self allows the constructor to assign values to instance variables (attributes) of the object being created.\n",
    "\n",
    "    Maintain Object-Specific Data:\n",
    "        Using self, each object can store its own unique data in instance variables.\n",
    "\n",
    "    Access Instance Variables:\n",
    "        Instance variables defined with self can be accessed by other methods within the class and externally via the object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "716862b3-e807-46ec-a79b-8fc85d8619d3",
   "metadata": {},
   "source": [
    "Q16. How do you prevent a class from having multiple instances by using constructors in Python? Provide an\n",
    "example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 355,
   "id": "395cba32-b218-48af-bdd6-857b0d2469d0",
   "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",
    "        # Using 'self' to initialize instance variables\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def display_info(self):\n",
    "        # Accessing instance variables with 'self'\n",
    "        print(f\"Name: {self.name}, Age: {self.age}\")\n",
    "\n",
    "# Creating objects\n",
    "person1 = Person(\"Alice\", 30)\n",
    "person2 = Person(\"Bob\", 25)\n",
    "\n",
    "# Accessing and displaying object-specific data\n",
    "person1.display_info()  # Output: Name: Alice, Age: 30\n",
    "person2.display_info()  # Output: Name: Bob, Age: 25\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da1ce21b-cc07-4351-bff2-85b907b7d55e",
   "metadata": {},
   "source": [
    "Q17. Create a Python class called `Student` with a constructor that takes a list of subjects as a parameter and\n",
    "initializes the `subjects` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 358,
   "id": "49914cba-1bc8-4624-b0d5-fd6b7a718fcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student Name: John Doe\n",
      "Subjects: Math, Science, History, English\n",
      "\n",
      "Student Name: Jane Smith\n",
      "Subjects: Art, Music, Physics\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, name, subjects):\n",
    "        self.name = name  # Initialize the student's name\n",
    "        self.subjects = subjects  # Initialize the list of subjects\n",
    "\n",
    "    def display_details(self):\n",
    "        # Display student details\n",
    "        print(f\"Student Name: {self.name}\")\n",
    "        print(\"Subjects:\", \", \".join(self.subjects))\n",
    "\n",
    "# Example usage\n",
    "subjects_list = [\"Math\", \"Science\", \"History\", \"English\"]\n",
    "student1 = Student(\"John Doe\", subjects_list)\n",
    "student2 = Student(\"Jane Smith\", [\"Art\", \"Music\", \"Physics\"])\n",
    "\n",
    "# Display details of each student\n",
    "student1.display_details()\n",
    "print()\n",
    "student2.display_details()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f45f063-fa11-4574-a4f0-8be21aceb3cc",
   "metadata": {},
   "source": [
    "Q18. What is the purpose of the `__del__` method in Python classes, and how does it relate to constructors?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c053d99-6a22-4f38-85ff-234583d36d33",
   "metadata": {},
   "source": [
    "Purpose of the __del__ Method in Python Classes\n",
    "\n",
    "The __del__ method in Python is a destructor method, which is used to define the behavior when an object is about to be destroyed (or when it goes out of scope). It is called when an object is garbage collected, i.e., when it is no longer referenced and the memory is being freed.\n",
    "Key Points:\n",
    "\n",
    "    Object Cleanup: __del__ is useful for releasing resources, closing files, network connections, or performing other cleanup tasks before an object is destroyed.\n",
    "    Automatic Invocation: It is automatically called when an object is garbage collected, though this is not guaranteed in all cases because Python uses reference counting and may not immediately destroy objects.\n",
    "    Doesn't Take Arguments: Like constructors, the __del__ method does not take explicit arguments (except for self).\n",
    "\n",
    "Difference Between __init__ and __del__:\n",
    "\n",
    "    __init__ (Constructor): Initializes the object when it is created.\n",
    "    __del__ (Destructor): Cleans up the object before it is destroyed."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba2b2347-951c-45e5-9903-d3ca48a6c0a8",
   "metadata": {},
   "source": [
    "Q19. Explain the use of constructor chaining in Python. Provide a practical example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "id": "56f395f3-d66f-4042-9811-ca6be03c55f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vehicle created: Toyota Corolla\n",
      "Car created: 2020 Toyota Corolla\n"
     ]
    }
   ],
   "source": [
    "#Constructor Chaining in Python\n",
    "\n",
    "'''Constructor chaining refers to the practice of calling one constructor from another constructor within the same class or\n",
    "between a parent and a child class. In Python, constructor chaining is typically done using the super() function, which allows a class\n",
    "to call the constructor of its parent class, enabling the reuse of the initialization logic.\n",
    "Purpose of Constructor Chaining:\n",
    "\n",
    "    Reuse Parent Constructor Logic: When a child class inherits from a parent class, the child class can call the parent class constructor to reuse \n",
    "    its initialization code without needing to rewrite it.\n",
    "    Ensure Proper Initialization: It ensures that both the child and parent classes are properly initialized, especially when multiple levels of\n",
    "    inheritance are involved.\n",
    "\n",
    "# Constructor Chaining Between Parent and Child Classes\n",
    "\n",
    "    In Child Class: The child class constructor can call the parent class constructor using super().__init__() to initialize the inherited attributes.\n",
    "    Within the Same Class: The super() function can also be used to call another constructor within the same class, allowing for more complex\n",
    "    initialization sequences.'''\n",
    "\n",
    "#Example: Constructor Chaining Between Parent and Child Classes\n",
    "\n",
    "class Vehicle:\n",
    "    def __init__(self, make, model):\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        print(f\"Vehicle created: {self.make} {self.model}\")\n",
    "\n",
    "class Car(Vehicle):\n",
    "    def __init__(self, make, model, year):\n",
    "        # Calling the parent class constructor to initialize the inherited attributes\n",
    "        super().__init__(make, model)\n",
    "        self.year = year\n",
    "        print(f\"Car created: {self.year} {self.make} {self.model}\")\n",
    "\n",
    "# Example usage\n",
    "car1 = Car(\"Toyota\", \"Corolla\", 2020)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55c18305-3fbd-4e21-b0dc-56e7d1491479",
   "metadata": {},
   "source": [
    "Q20. Create a Python class called `Car` with a default constructor that initializes the `make` and `model`\n",
    "attributes. Provide a method to display car information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "id": "c550255f-e35d-49b9-a658-5acd1f9b6a02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car Make: Toyota\n",
      "Car Model: Corolla\n",
      "\n",
      "Car Make: Honda\n",
      "Car Model: Civic\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    def __init__(self, make, model):\n",
    "        # Initialize make and model attributes\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "\n",
    "    def display_info(self):\n",
    "        # Method to display the car's make and model\n",
    "        print(f\"Car Make: {self.make}\")\n",
    "        print(f\"Car Model: {self.model}\")\n",
    "\n",
    "# Example usage\n",
    "car1 = Car(\"Toyota\", \"Corolla\")\n",
    "car2 = Car(\"Honda\", \"Civic\")\n",
    "\n",
    "# Display car information\n",
    "car1.display_info()\n",
    "print()\n",
    "car2.display_info()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1939fcc-2c4c-47db-91bd-28b1567b6a83",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ba243484-bcb7-444c-bad8-38f9ac36305b",
   "metadata": {},
   "source": [
    "                                                                    Polymorphism:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20814b13-7105-4b9f-98c1-21bba453c1fa",
   "metadata": {},
   "source": [
    "Q 1. What is polymorphism in Python? Explain how it is related to object-oriented programming."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36f20d58-8a1a-4931-810a-913492d32450",
   "metadata": {},
   "source": [
    "Polymorphism in Python is a concept in object-oriented programming that allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to represent different underlying forms (data types).\n",
    "Key Aspects of Polymorphism:\n",
    "\n",
    "    Method Overriding: Subclasses provide specific implementations for methods defined in a parent class. For example, the same method name can perform different tasks depending on the object that calls it.\n",
    "    Duck Typing: Python's dynamic typing allows objects to be treated based on their methods and properties, rather than their actual class.\n",
    "\n",
    "Relation to Object-Oriented Programming (OOP):\n",
    "\n",
    "    Polymorphism supports inheritance by enabling derived classes to customize or extend base class functionality.\n",
    "    It encourages code reusability and flexibility, allowing for generalized code that works with different object types."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdfc84aa-efe1-48d2-99b4-dde9c2d77075",
   "metadata": {},
   "source": [
    "Q2. Describe the difference between compile-time polymorphism and runtime polymorphism in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5072c3e7-9100-4169-bd6f-dd160929e6bb",
   "metadata": {},
   "source": [
    "1. Compile-Time Polymorphism (Static Polymorphism):\n",
    "\n",
    "    Definition: The method to be called is determined at the time of code compilation.\n",
    "    Common in: Statically typed languages like C++ or Java, usually through method overloading.\n",
    "    Python's limitation: Python does not directly support method overloading. Instead, you can achieve similar functionality by using default parameters or variable-length arguments\n",
    "\n",
    "2. Runtime Polymorphism (Dynamic Polymorphism):\n",
    "\n",
    "    Definition: The method to be called is determined at runtime, based on the object's type.\n",
    "    Common in: Object-oriented programming, achieved via method overriding.\n",
    "    In Python: Runtime polymorphism is directly supported and extensively used\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "739715de-3f73-49e0-8760-2efedf5034e9",
   "metadata": {},
   "source": [
    "Q3. Create a Python class hierarchy for shapes (e.g., circle, square, triangle) and demonstrate polymorphism\n",
    "through a common method, such as `calculate_area()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "04f9eca9-a7ee-4a32-b3e0-197308e6a723",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area of the Circle is: 78.53981633974483\n",
      "The area of the Square is: 16\n",
      "The area of the Triangle is: 9.0\n"
     ]
    }
   ],
   "source": [
    "from math import pi\n",
    "\n",
    "# Base class\n",
    "class Shape:\n",
    "    def calculate_area(self):\n",
    "        raise NotImplementedError(\"This method should be implemented by subclasses\")\n",
    "\n",
    "# Derived class for Circle\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "    \n",
    "    def calculate_area(self):\n",
    "        return pi * self.radius**2\n",
    "\n",
    "# Derived class for Square\n",
    "class Square(Shape):\n",
    "    def __init__(self, side):\n",
    "        self.side = side\n",
    "    \n",
    "    def calculate_area(self):\n",
    "        return self.side**2\n",
    "\n",
    "# Derived class for Triangle\n",
    "class Triangle(Shape):\n",
    "    def __init__(self, base, height):\n",
    "        self.base = base\n",
    "        self.height = height\n",
    "    \n",
    "    def calculate_area(self):\n",
    "        return 0.5 * self.base * self.height\n",
    "\n",
    "# Polymorphism in action\n",
    "shapes = [\n",
    "    Circle(radius=5),\n",
    "    Square(side=4),\n",
    "    Triangle(base=6, height=3)\n",
    "]\n",
    "\n",
    "for shape in shapes:\n",
    "    print(f\"The area of the {shape.__class__.__name__} is: {shape.calculate_area()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "800018f4-173c-4511-a280-cd7fa9d0d0ff",
   "metadata": {},
   "source": [
    "Q4. Explain the concept of method overriding in polymorphism. Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98ee68a1-dd59-4fec-947c-7c765c549bf8",
   "metadata": {},
   "source": [
    "Method Overriding in Polymorphism\n",
    "\n",
    "Definition:\n",
    "Method overriding occurs in object-oriented programming when a subclass provides a specific implementation of a method that is already defined in its superclass. This allows the subclass to modify or extend the behavior of the method while retaining its interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "dc5f8022-2321-4ed3-81fa-1b34d897a79f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal: Some generic sound\n",
      "Dog: Woof!\n",
      "Cat: Meow!\n"
     ]
    }
   ],
   "source": [
    "# Superclass\n",
    "class Animal:\n",
    "    def speak(self):\n",
    "        return \"Some generic sound\"\n",
    "\n",
    "# Subclass\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "# Demonstrating method overriding\n",
    "animals = [Animal(), Dog(), Cat()]\n",
    "\n",
    "for animal in animals:\n",
    "    print(f\"{animal.__class__.__name__}: {animal.speak()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9153eef9-b501-44ad-bac9-90ed24869c43",
   "metadata": {},
   "source": [
    "Q5. How is polymorphism different from method overloading in Python? Provide examples for both."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fd7c4fa-d84d-40fb-820a-2930a5819ec3",
   "metadata": {},
   "source": [
    "Polymorphism\n",
    "\n",
    "Definition\tA concept where the same method name can perform different tasks based on the object's type or context.\t \n",
    "Focus\tBehavior varies depending on the type of object.\t\n",
    "Support in Python\tFully supported (e.g., through method overriding). \n",
    "Type\tTypically runtime behavior (dynamic).\t\n",
    "\n",
    "Method Overloading\n",
    "\n",
    "Definition- A technique to define multiple methods with the same name but different parameters.\n",
    "Focus- Functionality varies depending on the arguments passed.\n",
    "Support- Not directly supported; achieved using default arguments or variable-length arguments.\n",
    "Type- Typically compile-time behavior (static)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2055799-05b0-4865-bfc9-9abc313e5b7a",
   "metadata": {},
   "source": [
    "Q6. Create a Python class called `Animal` with a method `speak()`. Then, create child classes like `Dog`, `Cat`, and `Bird`, each with their own `speak()` method. Demonstrate polymorphism by calling the `speak()` method\n",
    "on objects of different subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "dfca2f0d-ddeb-4309-8a9b-db198fca8467",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog: Woof!\n",
      "Cat: Meow!\n",
      "Bird: Chirp!\n"
     ]
    }
   ],
   "source": [
    "# Base class\n",
    "class Animal:\n",
    "    def speak(self):\n",
    "        return \"Some generic animal sound\"\n",
    "\n",
    "# Subclass for Dog\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "# Subclass for Cat\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "# Subclass for Bird\n",
    "class Bird(Animal):\n",
    "    def speak(self):\n",
    "        return \"Chirp!\"\n",
    "\n",
    "# Demonstrating polymorphism\n",
    "def make_animal_speak(animal):\n",
    "    print(f\"{animal.__class__.__name__}: {animal.speak()}\")\n",
    "\n",
    "# Creating objects of different subclasses\n",
    "animals = [Dog(), Cat(), Bird()]\n",
    "\n",
    "# Calling the speak() method polymorphically\n",
    "for animal in animals:\n",
    "    make_animal_speak(animal)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93b9398d-fe04-4b6e-bfde-8af1f4d8f73d",
   "metadata": {},
   "source": [
    "Q7. Discuss the use of abstract methods and classes in achieving polymorphism in Python. Provide an example\n",
    "using the `abc` module."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17913833-42d1-4ad1-acb1-23ee509bf1af",
   "metadata": {},
   "source": [
    "Abstract Methods and Classes in Achieving Polymorphism\n",
    "\n",
    "In Python, abstract classes and abstract methods provide a blueprint for other classes. Abstract classes are useful for achieving polymorphism because they define methods that must be implemented in subclasses, ensuring consistent behavior across different subclasses.\n",
    "\n",
    "    Abstract Class: A class that cannot be instantiated directly and contains one or more abstract methods.\n",
    "    Abstract Method: A method declared in an abstract class that lacks implementation and must be overridden by subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "2ce1f62c-a644-41c9-aecb-1756e83f6404",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog: Woof!\n",
      "Cat: Meow!\n",
      "Bird: Chirp!\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract Base Class\n",
    "class Animal(ABC):\n",
    "    @abstractmethod\n",
    "    def speak(self):\n",
    "        \"\"\"Subclasses must implement this method\"\"\"\n",
    "        pass\n",
    "\n",
    "# Subclass for Dog\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "# Subclass for Cat\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "# Subclass for Bird\n",
    "class Bird(Animal):\n",
    "    def speak(self):\n",
    "        return \"Chirp!\"\n",
    "\n",
    "# Demonstrating polymorphism\n",
    "def make_animal_speak(animal):\n",
    "    print(f\"{animal.__class__.__name__}: {animal.speak()}\")\n",
    "\n",
    "# Creating objects of subclasses\n",
    "animals = [Dog(), Cat(), Bird()]\n",
    "\n",
    "# Calling the speak() method polymorphically\n",
    "for animal in animals:\n",
    "    make_animal_speak(animal)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31cf8981-0572-4466-94d5-58d014af4603",
   "metadata": {},
   "source": [
    "Q8. Create a Python class hierarchy for a vehicle system (e.g., car, bicycle, boat) and implement a polymorphic `start()` method that prints a message specific to each vehicle type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "829ba760-1fb6-438c-9f36-57b55afddc18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car: The car engine starts with a roar!\n",
      "Bicycle: The bicycle is ready to pedal!\n",
      "Boat: The boat engine hums as it starts!\n"
     ]
    }
   ],
   "source": [
    "# Base class\n",
    "class Vehicle:\n",
    "    def start(self):\n",
    "        raise NotImplementedError(\"Subclasses must implement the start method\")\n",
    "\n",
    "# Subclass for Car\n",
    "class Car(Vehicle):\n",
    "    def start(self):\n",
    "        return \"The car engine starts with a roar!\"\n",
    "\n",
    "# Subclass for Bicycle\n",
    "class Bicycle(Vehicle):\n",
    "    def start(self):\n",
    "        return \"The bicycle is ready to pedal!\"\n",
    "\n",
    "# Subclass for Boat\n",
    "class Boat(Vehicle):\n",
    "    def start(self):\n",
    "        return \"The boat engine hums as it starts!\"\n",
    "\n",
    "# Demonstrating polymorphism\n",
    "def start_vehicle(vehicle):\n",
    "    print(f\"{vehicle.__class__.__name__}: {vehicle.start()}\")\n",
    "\n",
    "# Creating objects of different vehicles\n",
    "vehicles = [Car(), Bicycle(), Boat()]\n",
    "\n",
    "# Calling the start() method polymorphically\n",
    "for vehicle in vehicles:\n",
    "    start_vehicle(vehicle)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2b2c9ef-0a74-4863-95a1-947473aec430",
   "metadata": {},
   "source": [
    "Q9. Explain the significance of the `isinstance()` and `issubclass()` functions in Python polymorphism."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "a6dcb6da-22bc-4f0a-8dc5-97d3938db895",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        return \"Some generic sound\"\n",
    "\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "# Checking if Dog and Cat are subclasses of Animal\n",
    "print(issubclass(Dog, Animal))  # Output: True\n",
    "print(issubclass(Cat, Animal))  # Output: True\n",
    "print(issubclass(Dog, Cat))     # Output: False\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c2595a1-729d-4b2e-8e60-edae831b301e",
   "metadata": {},
   "source": [
    "Q10. What is the role of the `@abstractmethod` decorator in achieving polymorphism in Python? Provide an\n",
    "example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2dd3b59-3bec-4ad6-b60c-7c4fb5b97d82",
   "metadata": {},
   "source": [
    "Role of the @abstractmethod Decorator in Achieving Polymorphism in Python\n",
    "\n",
    "In Python, the @abstractmethod decorator is used to define an abstract method within an abstract base class (ABC). The @abstractmethod decorator enforces that a method in the base class has no implementation and must be implemented by any subclass that inherits from this base class.\n",
    "\n",
    "The use of abstract methods ensures that subclasses follow a common interface and implement specific functionality, allowing polymorphism to be achieved in a structured way. This helps in defining a clear contract that subclasses must fulfill."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "2a15dcb0-48d4-48d1-9f6e-819887a862a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog: Woof!\n",
      "Cat: Meow!\n",
      "Bird: Chirp!\n"
     ]
    }
   ],
   "source": [
    " from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract Base Class\n",
    "class Animal(ABC):\n",
    "    @abstractmethod\n",
    "    def speak(self):\n",
    "        \"\"\"Subclasses must implement this method\"\"\"\n",
    "        pass\n",
    "\n",
    "# Subclass for Dog\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "# Subclass for Cat\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "# Subclass for Bird\n",
    "class Bird(Animal):\n",
    "    def speak(self):\n",
    "        return \"Chirp!\"\n",
    "\n",
    "# Demonstrating polymorphism\n",
    "def make_animal_speak(animal: Animal):\n",
    "    print(f\"{animal.__class__.__name__}: {animal.speak()}\")\n",
    "\n",
    "# Creating objects of different animals\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "bird = Bird()\n",
    "\n",
    "# Calling the speak() method polymorphically\n",
    "make_animal_speak(dog)   # Output: Dog: Woof!\n",
    "make_animal_speak(cat)   # Output: Cat: Meow!\n",
    "make_animal_speak(bird)  # Output: Bird: Chirp!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1577b099-78c6-47e3-b254-b8eb61774507",
   "metadata": {},
   "source": [
    "Q11. Create a Python class called `Shape` with a polymorphic method `area()` that calculates the area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "01ac36e0-10e2-4a5f-8565-c75f1775d0c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area of Circle is: 78.53981633974483\n",
      "The area of Rectangle is: 24\n",
      "The area of Triangle is: 6.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# Base class for Shape\n",
    "class Shape:\n",
    "    def area(self):\n",
    "        raise NotImplementedError(\"Subclasses must implement this method\")\n",
    "\n",
    "# Subclass for Circle\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "    \n",
    "    def area(self):\n",
    "        return math.pi * self.radius ** 2\n",
    "\n",
    "# Subclass for Rectangle\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "    \n",
    "    def area(self):\n",
    "        return self.length * self.width\n",
    "\n",
    "# Subclass for Triangle\n",
    "class Triangle(Shape):\n",
    "    def __init__(self, base, height):\n",
    "        self.base = base\n",
    "        self.height = height\n",
    "    \n",
    "    def area(self):\n",
    "        return 0.5 * self.base * self.height\n",
    "\n",
    "# Demonstrating polymorphism\n",
    "def print_area(shape: Shape):\n",
    "    print(f\"The area of {shape.__class__.__name__} is: {shape.area()}\")\n",
    "\n",
    "# Creating objects of different shapes\n",
    "circle = Circle(5)\n",
    "rectangle = Rectangle(4, 6)\n",
    "triangle = Triangle(3, 4)\n",
    "\n",
    "# Calling the area() method polymorphically\n",
    "print_area(circle)     # Output: The area of Circle is: 78.53981633974483\n",
    "print_area(rectangle)  # Output: The area of Rectangle is: 24\n",
    "print_area(triangle)   # Output: The area of Triangle is: 6.0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "274fa8eb-8c77-47d5-89ac-f9930619a08c",
   "metadata": {},
   "source": [
    "Q12. Discuss the benefits of polymorphism in terms of code reusability and flexibility in Python programs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb71dd07-102f-4013-8041-c337ab355f8c",
   "metadata": {},
   "source": [
    "Polymorphism is a key concept in object-oriented programming (OOP) that offers significant benefits in terms of code reusability and flexibility in Python programs. Below are the primary advantages:\n",
    "1. Code Reusability\n",
    "\n",
    "Polymorphism allows you to write more generic and reusable code. With polymorphism, you can define a common interface (method signature) in a base class and then implement it differently in subclasses. This reduces the need for redundant code and allows the same code to operate on different types of objects.\n",
    "How Polymorphism Promotes Code Reusability:\n",
    "\n",
    "    You can create functions or methods that work with objects of various types, as long as those types implement the required methods.\n",
    "    The same function or class can be reused with different subclasses without having to write multiple versions of the same code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "680d9e12-2a1a-4642-b8c1-d218ea23b962",
   "metadata": {},
   "source": [
    "Q13. Explain the use of the `super()` function in Python polymorphism. How does it help call methods of parent\n",
    "classes?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b116142c-a0f8-4d68-8c32-5e180c2c521c",
   "metadata": {},
   "source": [
    "The super() function in Python is used to call methods from a parent class in the context of inheritance, and it plays an important role in polymorphism. It allows a subclass to call methods in its parent class, facilitating the reuse of code and the enhancement of the inherited functionality.\n",
    "Purpose of super() in Python Polymorphism:\n",
    "\n",
    "    Access Parent Class Methods: super() provides a way to call a method from a parent class without explicitly referencing the parent class by name. This is particularly useful in method overriding (where a subclass provides a different implementation of a method defined in its parent class).\n",
    "\n",
    "    Maintain Parent Class Behavior: In polymorphism, a subclass may want to extend the behavior of the parent class's method, rather than completely replace it. super() allows the subclass to call the parent class's method and then add its own functionality.\n",
    "\n",
    "    Multiple Inheritance: In multiple inheritance scenarios, super() ensures that methods from all parent classes are called in the correct order according to the method resolution order (MRO). This is especially useful when working with classes that inherit from more than one class.\n",
    "\n",
    "How super() Works:\n",
    "\n",
    "    The super() function returns a proxy object that represents the parent class. By calling methods on this proxy, you invoke methods in the parent class.\n",
    "    The syntax super().method_name() calls the method from the parent class.\n",
    "    In multiple inheritance, super() respects the MRO and ensures that methods from all parent classes are executed in a predictable order."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e395b2f-1eae-41ea-af70-674df9cf1726",
   "metadata": {},
   "source": [
    "Q14. Create a Python class hierarchy for a banking system with various account types (e.g., savings,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "132703ac-b77e-4c29-a622-b4022a7d516c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Account holder: John Doe\n",
      "Deposited 500. New balance: 1500\n",
      "Interest rate for Savings Account: 3.5%\n",
      "Withdrew 200 from Savings Account. New balance: 1300\n",
      "Balance after transactions: 1300\n",
      "Applied interest of 45.50000000000001. New balance: 1345.5\n",
      "\n",
      "Account holder: Jane Smith\n",
      "Deposited 500. New balance: 1000\n",
      "Withdrew 200 from Checking Account. New balance: 800\n",
      "Balance after transactions: 800\n",
      "Overdraft limit: 200\n"
     ]
    }
   ],
   "source": [
    "# Base class for all types of bank accounts\n",
    "class BankAccount:\n",
    "    def __init__(self, account_holder: str, balance: float):\n",
    "        self.account_holder = account_holder\n",
    "        self.balance = balance\n",
    "    \n",
    "    def deposit(self, amount: float):\n",
    "        if amount > 0:\n",
    "            self.balance += amount\n",
    "            print(f\"Deposited {amount}. New balance: {self.balance}\")\n",
    "        else:\n",
    "            print(\"Deposit amount must be positive.\")\n",
    "    \n",
    "    def withdraw(self, amount: float):\n",
    "        # General withdrawal method for the base class (can be overridden)\n",
    "        if amount > 0 and amount <= self.balance:\n",
    "            self.balance -= amount\n",
    "            print(f\"Withdrew {amount}. New balance: {self.balance}\")\n",
    "        else:\n",
    "            print(\"Insufficient funds or invalid withdrawal amount.\")\n",
    "    \n",
    "    def get_balance(self):\n",
    "        return self.balance\n",
    "\n",
    "# SavingsAccount subclass with specific rules for withdrawal\n",
    "class SavingsAccount(BankAccount):\n",
    "    def __init__(self, account_holder: str, balance: float, interest_rate: float):\n",
    "        super().__init__(account_holder, balance)\n",
    "        self.interest_rate = interest_rate\n",
    "    \n",
    "    def deposit(self, amount: float):\n",
    "        super().deposit(amount)\n",
    "        print(f\"Interest rate for Savings Account: {self.interest_rate}%\")\n",
    "    \n",
    "    def withdraw(self, amount: float):\n",
    "        # Savings account may have specific withdrawal rules (e.g., limit on free withdrawals)\n",
    "        if amount <= self.balance:\n",
    "            self.balance -= amount\n",
    "            print(f\"Withdrew {amount} from Savings Account. New balance: {self.balance}\")\n",
    "        else:\n",
    "            print(\"Insufficient funds in Savings Account.\")\n",
    "    \n",
    "    def apply_interest(self):\n",
    "        interest = self.balance * (self.interest_rate / 100)\n",
    "        self.balance += interest\n",
    "        print(f\"Applied interest of {interest}. New balance: {self.balance}\")\n",
    "\n",
    "# CheckingAccount subclass with specific rules for withdrawal\n",
    "class CheckingAccount(BankAccount):\n",
    "    def __init__(self, account_holder: str, balance: float, overdraft_limit: float):\n",
    "        super().__init__(account_holder, balance)\n",
    "        self.overdraft_limit = overdraft_limit\n",
    "    \n",
    "    def withdraw(self, amount: float):\n",
    "        # Checking account allows overdraft (i.e., balance can go below 0)\n",
    "        if amount > 0 and (self.balance + self.overdraft_limit) >= amount:\n",
    "            self.balance -= amount\n",
    "            print(f\"Withdrew {amount} from Checking Account. New balance: {self.balance}\")\n",
    "        else:\n",
    "            print(\"Insufficient funds or overdraft limit reached.\")\n",
    "    \n",
    "    def get_overdraft_limit(self):\n",
    "        return self.overdraft_limit\n",
    "\n",
    "# Demonstrating polymorphism with different account types\n",
    "def demonstrate_polymorphism(account: BankAccount):\n",
    "    print(f\"\\nAccount holder: {account.account_holder}\")\n",
    "    account.deposit(500)\n",
    "    account.withdraw(200)\n",
    "    print(f\"Balance after transactions: {account.get_balance()}\")\n",
    "\n",
    "    if isinstance(account, SavingsAccount):\n",
    "        account.apply_interest()\n",
    "    elif isinstance(account, CheckingAccount):\n",
    "        print(f\"Overdraft limit: {account.get_overdraft_limit()}\")\n",
    "\n",
    "# Create instances of SavingsAccount and CheckingAccount\n",
    "savings_account = SavingsAccount(\"John Doe\", 1000, 3.5)\n",
    "checking_account = CheckingAccount(\"Jane Smith\", 500, 200)\n",
    "\n",
    "# Demonstrating polymorphism\n",
    "demonstrate_polymorphism(savings_account)\n",
    "demonstrate_polymorphism(checking_account)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fc85c50-abeb-4a68-a043-1f1b31b76ec5",
   "metadata": {},
   "source": [
    "Q15. Describe the concept of operator overloading in Python and how it relates to polymorphism. Provide\n",
    "examples using operators like `+` and `*`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffed362f-ba1c-49b2-8ccf-a37420b64453",
   "metadata": {},
   "source": [
    "Operator Overloading in Python and its Relationship to Polymorphism\n",
    "\n",
    "Operator overloading allows you to define the behavior of standard operators (like +, -, *, etc.) for user-defined classes. This means you can customize how objects of a class interact with these operators, providing more intuitive or domain-specific behavior for those objects.\n",
    "\n",
    "In Python, operators are implemented using special methods (also known as magic methods or dunder methods) that are automatically invoked when you use operators on objects. For example, the + operator is implemented using the __add__() method, and the * operator is implemented using the __mul__() method.\n",
    "Relationship to Polymorphism:\n",
    "\n",
    "Operator overloading is closely related to polymorphism because it allows objects of different classes to respond to the same operator in a way that is specific to their type. This means that the same operator can behave differently depending on the class of the objects involved, demonstrating dynamic dispatch (a core principle of polymorphism)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "134812f6-23c5-41c0-becc-8663d8ed998d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v1: Vector(2, 3)\n",
      "v2: Vector(1, 1)\n",
      "v1 + v2 = Vector(3, 4)\n",
      "v1 * 3 = Vector(6, 9)\n"
     ]
    }
   ],
   "source": [
    " class Vector:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Vector({self.x}, {self.y})\"\n",
    "\n",
    "    # Overloading the '+' operator (vector addition)\n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, Vector):\n",
    "            return Vector(self.x + other.x, self.y + other.y)\n",
    "        return NotImplemented\n",
    "\n",
    "    # Overloading the '*' operator (scalar multiplication)\n",
    "    def __mul__(self, scalar):\n",
    "        if isinstance(scalar, (int, float)):  # Ensuring scalar multiplication\n",
    "            return Vector(self.x * scalar, self.y * scalar)\n",
    "        return NotImplemented\n",
    "\n",
    "# Create two vector objects\n",
    "v1 = Vector(2, 3)\n",
    "v2 = Vector(1, 1)\n",
    "\n",
    "# Demonstrate operator overloading\n",
    "v3 = v1 + v2  # Vector addition\n",
    "v4 = v1 * 3   # Scalar multiplication\n",
    "\n",
    "print(f\"v1: {v1}\")\n",
    "print(f\"v2: {v2}\")\n",
    "print(f\"v1 + v2 = {v3}\")\n",
    "print(f\"v1 * 3 = {v4}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38a75599-63a5-43a4-92b3-c2634793f878",
   "metadata": {},
   "source": [
    "Q16. What is dynamic polymorphism, and how is it achieved in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00400859-3ecb-4ce9-b4c5-e2f534152beb",
   "metadata": {},
   "source": [
    "Dynamic Polymorphism in Python\n",
    "\n",
    "Dynamic polymorphism, also known as runtime polymorphism, refers to the ability of different objects to respond to the same method call in different ways at runtime. This occurs when the method being called is determined at runtime, based on the type of the object that is invoking it.\n",
    "\n",
    "In Python, dynamic polymorphism is typically achieved through method overriding and inheritance in object-oriented programming. This allows child classes to override methods in their parent class and provide their own implementation. When a method is called on an object, the correct version of the method (the one from the actual object type) is executed, even if the reference to the object is of the parent type.\n",
    "Key Features of Dynamic Polymorphism in Python:\n",
    "\n",
    "    Method Overriding: In a subclass, you can override a method from the parent class to provide a specific implementation. When you call this method on an instance of the subclass, the subclass version is executed.\n",
    "\n",
    "    Method Resolution Order (MRO): Python uses the method resolution order to determine which method to invoke when multiple classes are involved in inheritance. This is dynamically decided at runtime.\n",
    "\n",
    "    Late Binding: Python is dynamically typed, meaning the type of the object is known at runtime, and the appropriate method is bound to the object when the method is called."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98e57ddb-bfd0-4e70-a448-73365a5cc322",
   "metadata": {},
   "source": [
    "Q17. Create a Python class hierarchy for employees in a company (e.g., manager, developer, designer) and implement polymorphism through a common `calculate_salary()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "31f2d0ba-487d-4d48-bcae-f7979d02b311",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice's Salary: 7000\n",
      "Bob's Salary: 5000\n",
      "Charlie's Salary: 4500\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    def __init__(self, name: str, base_salary: float):\n",
    "        self.name = name\n",
    "        self.base_salary = base_salary\n",
    "    \n",
    "    # Common method, to be overridden by subclasses\n",
    "    def calculate_salary(self):\n",
    "        return self.base_salary\n",
    "\n",
    "class Manager(Employee):\n",
    "    def __init__(self, name: str, base_salary: float, bonus: float):\n",
    "        super().__init__(name, base_salary)\n",
    "        self.bonus = bonus\n",
    "    \n",
    "    # Overriding the calculate_salary method to include a bonus\n",
    "    def calculate_salary(self):\n",
    "        return self.base_salary + self.bonus\n",
    "\n",
    "class Developer(Employee):\n",
    "    def __init__(self, name: str, base_salary: float, overtime_hours: float, overtime_rate: float):\n",
    "        super().__init__(name, base_salary)\n",
    "        self.overtime_hours = overtime_hours\n",
    "        self.overtime_rate = overtime_rate\n",
    "    \n",
    "    # Overriding the calculate_salary method to include overtime pay\n",
    "    def calculate_salary(self):\n",
    "        overtime_pay = self.overtime_hours * self.overtime_rate\n",
    "        return self.base_salary + overtime_pay\n",
    "\n",
    "class Designer(Employee):\n",
    "    def __init__(self, name: str, base_salary: float, commission: float):\n",
    "        super().__init__(name, base_salary)\n",
    "        self.commission = commission\n",
    "    \n",
    "    # Overriding the calculate_salary method to include a commission\n",
    "    def calculate_salary(self):\n",
    "        return self.base_salary + self.commission\n",
    "\n",
    "# Create instances of different employee types\n",
    "manager = Manager(\"Alice\", 5000, 2000)\n",
    "developer = Developer(\"Bob\", 4000, 20, 50)\n",
    "designer = Designer(\"Charlie\", 3500, 1000)\n",
    "\n",
    "# Demonstrating polymorphism: calling calculate_salary on each object\n",
    "employees = [manager, developer, designer]\n",
    "\n",
    "for employee in employees:\n",
    "    print(f\"{employee.name}'s Salary: {employee.calculate_salary()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38d5a8b9-bf42-4b56-b492-5f518dcd934f",
   "metadata": {},
   "source": [
    "Q18. Discuss the concept of function pointers and how they can be used to achieve polymorphism in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "ff3c3725-fe56-4821-8dcd-79f07efb770d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition: 8\n",
      "Multiplication: 15\n"
     ]
    }
   ],
   "source": [
    "# Define some functions that simulate polymorphic behavior\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "def multiply(x, y):\n",
    "    return x * y\n",
    "\n",
    "# A function that takes another function as a parameter (function pointer)\n",
    "def calculate(a, b, operation):\n",
    "    return operation(a, b)\n",
    "\n",
    "# Demonstrating polymorphism\n",
    "x, y = 5, 3\n",
    "\n",
    "# Pass different functions (add or multiply) as arguments\n",
    "print(\"Addition:\", calculate(x, y, add))        # Outputs 8\n",
    "print(\"Multiplication:\", calculate(x, y, multiply))  # Outputs 15\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ffd9092-39da-447a-a4f5-59460c1591e3",
   "metadata": {},
   "source": [
    "Q19. Explain the role of interfaces and abstract classes in polymorphism, drawing comparisons between them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "533d20b5-ce94-4fcd-aa97-080638c81b83",
   "metadata": {},
   "source": [
    "1. Abstract Classes\n",
    "\n",
    "An abstract class is a class that cannot be instantiated directly. It serves as a blueprint for other classes. Abstract classes can have both abstract methods (methods without implementation) and concrete methods (methods with implementation). The primary purpose of abstract classes is to provide a common base for derived classes, enforcing the implementation of certain methods while allowing flexibility in others.\n",
    "Role in Polymorphism:\n",
    "\n",
    "    Abstract classes provide polymorphism by defining a common interface that subclasses must implement. Any subclass of an abstract class is expected to provide its own implementation of the abstract methods, while still adhering to the overall contract set by the abstract class..\n",
    "\n",
    "2. Interfaces\n",
    "\n",
    "An interface is a concept used to define a set of methods that a class must implement, but unlike abstract classes, interfaces cannot have any method implementations. In Python, we don't have formal interfaces like in languages such as Java or C#, but Python achieves similar functionality using abstract base classes (ABCs) from the abc module. In some languages, an interface is purely a contract, and classes are required to implement all methods declared in the interface.\n",
    "Role in Polymorphism:\n",
    "\n",
    "    Interfaces define a contract for a set of methods that must be implemented by any class that adopts the interface. This ensures that any class implementing the interface can be treated uniformly (polymorphic behavior) based on the interface methods, regardless of the actual class.\n",
    "    An interface enforces a strict form of polymorphism because all implementing classes are guaranteed to have the same method signatures, but with different implementations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "964ee2a3-09fa-4a08-ba4d-9b6018becc5f",
   "metadata": {},
   "source": [
    "Q20. Create a Python class for a zoo simulation, demonstrating polymorphism with different animal types (e.g., mammals, birds, reptiles) and their behavior (e.g., eating, sleeping, making sounds)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "1e3f8a3c-b506-4525-a365-bdcdd81cb6ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mammal:\n",
      "  Eat: Eating meat or plants.\n",
      "  Sleep: Sleeping in a den or nest.\n",
      "  Sound: Making a mammal sound (e.g., growl or roar).\n",
      "------------------------------\n",
      "Bird:\n",
      "  Eat: Eating seeds, worms, or fruits.\n",
      "  Sleep: Sleeping in a tree or nest.\n",
      "  Sound: Chirping or singing.\n",
      "------------------------------\n",
      "Reptile:\n",
      "  Eat: Eating insects, plants, or small animals.\n",
      "  Sleep: Sleeping in a burrow or under a rock.\n",
      "  Sound: Making a reptile sound (e.g., hiss or croak).\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Base class for Animal\n",
    "class Animal(ABC):\n",
    "    @abstractmethod\n",
    "    def eat(self):\n",
    "        pass\n",
    "    \n",
    "    @abstractmethod\n",
    "    def sleep(self):\n",
    "        pass\n",
    "    \n",
    "    @abstractmethod\n",
    "    def make_sound(self):\n",
    "        pass\n",
    "\n",
    "# Mammal class (inherits from Animal)\n",
    "class Mammal(Animal):\n",
    "    def eat(self):\n",
    "        return \"Eating meat or plants.\"\n",
    "    \n",
    "    def sleep(self):\n",
    "        return \"Sleeping in a den or nest.\"\n",
    "    \n",
    "    def make_sound(self):\n",
    "        return \"Making a mammal sound (e.g., growl or roar).\"\n",
    "\n",
    "# Bird class (inherits from Animal)\n",
    "class Bird(Animal):\n",
    "    def eat(self):\n",
    "        return \"Eating seeds, worms, or fruits.\"\n",
    "    \n",
    "    def sleep(self):\n",
    "        return \"Sleeping in a tree or nest.\"\n",
    "    \n",
    "    def make_sound(self):\n",
    "        return \"Chirping or singing.\"\n",
    "\n",
    "# Reptile class (inherits from Animal)\n",
    "class Reptile(Animal):\n",
    "    def eat(self):\n",
    "        return \"Eating insects, plants, or small animals.\"\n",
    "    \n",
    "    def sleep(self):\n",
    "        return \"Sleeping in a burrow or under a rock.\"\n",
    "    \n",
    "    def make_sound(self):\n",
    "        return \"Making a reptile sound (e.g., hiss or croak).\"\n",
    "\n",
    "# Demonstrating polymorphism\n",
    "def zoo_simulation(animals):\n",
    "    for animal in animals:\n",
    "        print(f\"{animal.__class__.__name__}:\")\n",
    "        print(f\"  Eat: {animal.eat()}\")\n",
    "        print(f\"  Sleep: {animal.sleep()}\")\n",
    "        print(f\"  Sound: {animal.make_sound()}\")\n",
    "        print(\"-\" * 30)\n",
    "\n",
    "# Creating instances of different animal types\n",
    "animals = [Mammal(), Bird(), Reptile()]\n",
    "\n",
    "# Run the zoo simulation (demonstrating polymorphism)\n",
    "zoo_simulation(animals)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd5beb89-e137-4b49-8926-3c6c5e5d65ae",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0270ac2e-c15d-4fc9-a8d3-a773790d896f",
   "metadata": {},
   "source": [
    "                                                                 Abstraction:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e66693a6-d69c-4f79-a2a8-0d705dd03af8",
   "metadata": {},
   "source": [
    "Q1. What is abstraction in Python, and how does it relate to object-oriented programming?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "574739f9-2815-4a82-b1ac-701bb2ebc4ab",
   "metadata": {},
   "source": [
    "Abstraction in Python and Its Relation to Object-Oriented Programming\n",
    "\n",
    "Abstraction is one of the core concepts of object-oriented programming (OOP). It involves hiding the implementation details of an object and exposing only the essential features to the user. Abstraction allows you to work with objects at a high level of understanding, without needing to know all the internal workings. It simplifies complex systems by focusing on what an object does rather than how it does it.\n",
    "\n",
    "In Python, abstraction is typically implemented using abstract classes and abstract methods, which allow you to define a common interface while leaving the implementation of specific behaviors to subclasses.\n",
    "Key Points of Abstraction:\n",
    "\n",
    "    Hides Complexity: Abstraction hides the complex implementation details and only shows the necessary aspects of an object.\n",
    "    Focuses on What, Not How: It allows users to interact with objects through simple interfaces and doesn't require knowledge of the inner workings.\n",
    "    Improves Maintainability: By isolating implementation details, it makes it easier to change or update the internal workings without affecting the external behavior.\n",
    "\n",
    "How Abstraction Relates to Object-Oriented Programming:\n",
    "\n",
    "    Object-Oriented Design: In OOP, abstraction helps define clear and simple interfaces for interacting with objects. It allows you to define abstract classes that provide a blueprint for other classes, ensuring that all subclasses adhere to a certain structure, while leaving the specific implementation to be filled in by those subclasses.\n",
    "    Separation of Concerns: By using abstraction, OOP encourages separation of concerns, which allows developers to focus on different parts of the system without worrying about unrelated details."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "200f3663-8b93-4647-b3dc-3f1092e15934",
   "metadata": {},
   "source": [
    "Q2. Describe the benefits of abstraction in terms of code organization and complexity reduction."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28556be6-c816-42c1-96ad-6af39699e296",
   "metadata": {},
   "source": [
    "Benefits of Abstraction in Code Organization and Complexity Reduction\n",
    "\n",
    "Abstraction is a fundamental concept in object-oriented programming (OOP) that provides several key benefits in terms of code organization and complexity reduction. By focusing on the essential aspects of objects and hiding the unnecessary details, abstraction helps developers manage large, complex systems with greater ease. Here are the main benefits of abstraction:\n",
    "1. Improved Code Organization\n",
    "\n",
    "Abstraction encourages a clean separation between the interface (what an object can do) and the implementation (how the object achieves it). This separation has several advantages:\n",
    "\n",
    "    Modular Design: Abstraction helps organize code into distinct, modular components. Each class or module can focus on a specific aspect of the system's behavior, and the complex details are hidden behind simple interfaces.\n",
    "        Example: A PaymentProcessor class might abstract the different ways payments can be processed (credit card, PayPal, etc.) while exposing a simple process_payment() method. This makes it easier to add new payment methods later without modifying the core functionality.\n",
    "    Clear Structure: By using abstract classes or interfaces to define common behaviors, you make the overall structure of the program clearer. It's easier to understand how different parts of the system interact through common abstractions without worrying about the inner workings of each component."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f02b75a-4244-4616-ba66-79d404fc240b",
   "metadata": {},
   "source": [
    "Q3. Create a Python class called `Shape` with an abstract method `calculate_area()`. Then, create child classes (e.g., `Circle`, `Rectangle`) that implement the `calculate_area()` method. Provide an example of\n",
    "using these classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "e334231d-6401-4557-8bc9-9932bcfca120",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circle Area: 78.54\n",
      "Rectangle Area: 24\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "import math\n",
    "\n",
    "# Abstract Base Class Shape\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def calculate_area(self):\n",
    "        pass  # Abstract method, to be implemented by subclasses\n",
    "\n",
    "# Subclass Circle\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "    \n",
    "    def calculate_area(self):\n",
    "        return math.pi * (self.radius ** 2)\n",
    "\n",
    "# Subclass Rectangle\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "    \n",
    "    def calculate_area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "# Using the classes\n",
    "def main():\n",
    "    # Create instances of Circle and Rectangle\n",
    "    circle = Circle(5)  # Radius of 5\n",
    "    rectangle = Rectangle(4, 6)  # Width of 4 and Height of 6\n",
    "    \n",
    "    # Calculate areas using the calculate_area method (polymorphism)\n",
    "    print(f\"Circle Area: {circle.calculate_area():.2f}\")\n",
    "    print(f\"Rectangle Area: {rectangle.calculate_area()}\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4f3634a-0a30-4638-af82-ff56905b5a0e",
   "metadata": {},
   "source": [
    "Q4. Explain the concept of abstract classes in Python and how they are defined using the `abc` module. Provide\n",
    "an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "03a9bfc6-489c-450c-b4c9-7a736a63e639",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog: Woof!\n",
      "Cat: Meow!\n",
      "Bird: Chirp!\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract Base Class\n",
    "class Animal(ABC):\n",
    "    @abstractmethod\n",
    "    def speak(self):\n",
    "        \"\"\"Subclasses must implement this method\"\"\"\n",
    "        pass\n",
    "\n",
    "# Subclass for Dog\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "# Subclass for Cat\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "# Subclass for Bird\n",
    "class Bird(Animal):\n",
    "    def speak(self):\n",
    "        return \"Chirp!\"\n",
    "\n",
    "# Demonstrating polymorphism\n",
    "def make_animal_speak(animal):\n",
    "    print(f\"{animal.__class__.__name__}: {animal.speak()}\")\n",
    "\n",
    "# Creating objects of subclasses\n",
    "animals = [Dog(), Cat(), Bird()]\n",
    "\n",
    "# Calling the speak() method polymorphically\n",
    "for animal in animals:\n",
    "    make_animal_speak(animal)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3952e975-ecdd-43f2-80d5-167f05b5ea30",
   "metadata": {},
   "source": [
    "Q5. How do abstract classes differ from regular classes in Python? Discuss their use cases."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04d9e7ba-0aa2-4a43-bc0f-620be8b8faae",
   "metadata": {},
   "source": [
    "Abstract Classes vs Regular Classes in Python\n",
    "\n",
    "In Python, abstract classes and regular classes both serve as blueprints for creating objects, but they have important differences in terms of usage, functionality, and behavior. Here's a detailed comparison:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad27a7dc-e9c7-4c2f-b8ba-efd65b57c409",
   "metadata": {},
   "source": [
    "Q6. Create a Python class for a bank account and demonstrate abstraction by hiding the account balance and\n",
    "providing methods to deposit and withdraw funds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "2d1b6dd7-504b-4b70-80e2-98f39459e27a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The area of Circle is: 78.53981633974483\n",
      "The area of Rectangle is: 24\n",
      "The area of Triangle is: 6.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    " \n",
    "class Shape:\n",
    "    def area(self):\n",
    "        raise NotImplementedError(\"Subclasses must implement this method\")\n",
    " \n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "    \n",
    "    def area(self):\n",
    "        return math.pi * self.radius ** 2\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "    \n",
    "    def area(self):\n",
    "        return self.length * self.width\n",
    "\n",
    "# Subclass for Triangle\n",
    "class Triangle(Shape):\n",
    "    def __init__(self, base, height):\n",
    "        self.base = base\n",
    "        self.height = height\n",
    "    \n",
    "    def area(self):\n",
    "        return 0.5 * self.base * self.height\n",
    " \n",
    "def print_area(shape: Shape):\n",
    "    print(f\"The area of {shape.__class__.__name__} is: {shape.area()}\")\n",
    " \n",
    "circle = Circle(5)\n",
    "rectangle = Rectangle(4, 6)\n",
    "triangle = Triangle(3, 4)\n",
    " \n",
    "print_area(circle)     \n",
    "print_area(rectangle)   \n",
    "print_area(triangle)    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e969f1e-32e8-45ca-b64a-5f2a82378f0d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "520b45e5-ea68-469a-a106-d535bd57de91",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "390c693e-6d09-40d2-b6ee-92889b0666eb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf2edb51-1eba-4391-b2a6-2e0b996ae27a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02639027-1990-4bc0-bfaf-c6a610d29750",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51fabc49-372b-41db-9916-015cf0c876bb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84a6e712-d6f6-4612-ace0-14e7870e36b5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12f7debc-87c2-421d-8889-f765f9717dca",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fe8d52e-14b8-481b-8bb8-47bb712be592",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "763db653-a134-4309-8963-0aafd9c921c5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2716563-03fb-4f5d-9f5f-f3136100a456",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a62aa36a-21ed-4ccb-9a4d-23522973a806",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}