15th_oct_oops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OOPS Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Constructor:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. What is a constructor in Python? Explain its purpose and usage.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, a constructor is a special method(magic method) that is automatically called when an object is created. The purpose of a constructor is to initialize the attributes of the object of the class. In other words, it is used to set up the initial state of an object.\n",
    "\n",
    "The constructor method in Python is named `__init__`. It takes as its first parameter the instance being created (usually named self), followed by any other parameters that we want to pass when creating an object. Within the constructor, we can set the initial values of the object's attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Raja\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "# Here's an example of a class with a constructor:\n",
    "\n",
    "\n",
    "#creating a class\n",
    "class Student:\n",
    "    # constructor\n",
    "    def __init__(self, name, roll):\n",
    "        self.name = name\n",
    "        self.roll = roll\n",
    "#creating an object of the class student, and the constructor is automatically called\n",
    "s1 = Student(\"Raja\",40) \n",
    "print(s1.name)\n",
    "print(s1.roll)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Differentiate between a parameterless constructor and a parameterized constructor in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paramaterless constructor:\n",
    "A parameterless constructor, also known as a default constructor, is a constructor that takes no parameters.It is often used when we want to create an object with default values for its attributes.\n",
    "The default constructor is named `__init__` and has the self parameter only, and no additional parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maths\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "\n",
    "class Exam:\n",
    "    def __init__(self):\n",
    "        # Default values for attributes\n",
    "        self.subject = \"Maths\"\n",
    "        self.marks = 50\n",
    "\n",
    "# Creating an object of class Exam\n",
    "student1 = Exam()\n",
    "\n",
    "print(student1.subject)\n",
    "print(student1.marks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameterized Constructor:\n",
    "\n",
    "A parameterized constructor is a constructor that takes one or more parameters.It is used when you want to customize the initialization of the object by providing values for its attributes during object creation.\n",
    "The parameterized constructor has the self parameter along with additional parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "English\n",
      "88\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "\n",
    "class Exam:\n",
    "    def __init__(self,subject,marks):\n",
    "        # Default values for attributes\n",
    "        self.subject = subject\n",
    "        self.marks = marks\n",
    "\n",
    "# Creating an object Exam\n",
    "student1 = Exam(\"English\",88)\n",
    "\n",
    "print(student1.subject)\n",
    "print(student1.marks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. How do you define a constructor in a Python class? Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "n Python, a constructor is defined using the `__init__` method within a class. The `__init__` method is automatically called when an object is created from the class and is used to initialize the attributes of the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Raman\n",
      "Roll: 46\n"
     ]
    }
   ],
   "source": [
    "# Here's an example of a class with a constructor:\n",
    "\n",
    "\n",
    "#creating a class\n",
    "class Student:\n",
    "    # constructor\n",
    "    def __init__(self, name, roll):\n",
    "        self.name = name\n",
    "        self.roll = roll\n",
    "#creating an object of the class student, and the constructor is automatically called\n",
    "s1 = Student(\"Raman\",46) \n",
    "print(\"Name:\",s1.name)\n",
    "print(\"Roll:\",s1.roll)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Explain the `__init__` method in Python and its role in constructors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `__init__` method in Python is a special method(magic method) that is automatically called when an object is created from a class. It is often referred to as the \"initializer\" or \"constructor\" method. The primary role of the `__init__` method is to initialize the attributes of the object, providing an opportunity to set up the initial state of the object.\n",
    "\n",
    "Here are key points about the `__init__` method and its role in constructors:\n",
    "\n",
    "## Initialization of Attributes:\n",
    "The primary purpose of the `__init__` method is to initialize the attributes of an object.\n",
    "Attributes represent the data members or properties of an object, and the `__init__` method is responsible for setting their initial values.\n",
    "\n",
    "## Automatic Invocation:\n",
    "The `__init__` method is automatically called when an object is created from a class.\n",
    "When we create an instance of a class using the class name followed by parentheses (e.g., obj = MyClass()), the `__init__` method is invoked with the newly created instance (obj) as its first parameter (self).\n",
    "\n",
    "## Use of self Parameter:\n",
    "The self parameter in the `__init__` method is a reference to the instance being created.\n",
    "It is a convention in Python to use self as the name of the first parameter, but we can technically use any name.\n",
    "\n",
    "## Setting Initial State:\n",
    "Inside the `__init__` method, we can set the initial state of the object by assigning values to its attributes.\n",
    "These attribute values are often based on the parameters passed to the `__init__` method, allowing for customization during object creation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maths\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "\n",
    "class Exam:\n",
    "    def __init__(self):\n",
    "        # Default values for attributes\n",
    "        self.subject = \"Maths\"\n",
    "        self.marks = 50\n",
    "\n",
    "# Creating an object of class Exam and __init__ in invoked automatically\n",
    "student1 = Exam()\n",
    "\n",
    "print(student1.subject)\n",
    "print(student1.marks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. In a class named `Person`, create a constructor that initializes the `name` and `age` attributes. Provide an example of creating an object of this class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: Akshay\n",
      "age: 56\n"
     ]
    }
   ],
   "source": [
    "#creating the class\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 Person\n",
    "p = Person(\"Akshay\",56)\n",
    "print(\"name:\",p.name)\n",
    "print(\"age:\",p.age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. How can you call a constructor explicitly in Python? Give an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, we don't typically call the constructor explicitly. The constructor, which is the `__init__` method, is automatically invoked when we create an object of a class. However, if we need to call a method explicitly after the object has been created, we can define another method in the class and call it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value is: 42\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "\n",
    "class MyClass:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "\n",
    "    def display_value(self):\n",
    "        print(\"The value is:\", self.value)\n",
    "\n",
    "# Creating an instance of MyClass\n",
    "obj = MyClass(42)\n",
    "\n",
    "# Calling a method explicitly after object creation\n",
    "obj.display_value()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. What is the significance of the `self` parameter in Python constructors? Explain with an example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, the self parameter in constructors is a reference to the instance of the class. It is a convention, not a keyword, and we can technically use any name for this parameter, but self is widely adopted and recommended for clarity. The purpose of self is to allow access to the attributes and methods of the instance within the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Raja\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Here's an example to illustrate the significance\n",
    "of the self parameter in a Python constructor:\n",
    "'''\n",
    "\n",
    "#creating a class\n",
    "class Student:\n",
    "    \n",
    "    # constructor\n",
    "    def __init__(self, name, roll):\n",
    "        #using self to refer to the instance attributes\n",
    "        self.name = name\n",
    "        self.roll = roll\n",
    "        \n",
    "    def display_info(self):\n",
    "        print(self.name)\n",
    "        print(self.roll)\n",
    "        \n",
    "#creating an object of the class student, and the constructor is automatically called\n",
    "s1 = Student(\"Raja\",40) \n",
    "# Accessing attributes and calling a method using 'self'\n",
    "s1.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Discuss the concept of default constructors in Python. When are they used?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A default constructor is a constructor that takes no arguments and is defined implicitly by Python if no other constructor is defined. It initializes all the instance variables of a class to their default values. The default constructor is called automatically when an object of the class is created.\n",
    "\n",
    "## Benefits of using default constructor:\n",
    "### Easy to use:\n",
    "Default constructors are easy to use and do not require any arguments to be passed while creating an object.\n",
    "### Code optimization:\n",
    "Using default constructors can optimize the code by reducing the number of parameters that need to be passed while creating an object.\n",
    "### Consistency:\n",
    "Using default constructors can ensure consistency across all objects of a class by initializing them to their default values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rajeev\n",
      "18\n",
      "A\n"
     ]
    }
   ],
   "source": [
    "# example\n",
    "class Student:\n",
    "    #default constructor\n",
    "    def __init__(self):\n",
    "        self.name = \"Rajeev\"\n",
    "        self.age = 18\n",
    "        self.grade = \"A\"\n",
    "    \n",
    "    def display_info(self):\n",
    "        print(self.name)\n",
    "        print(self.age)\n",
    "        print(self.grade)\n",
    "    \n",
    "        \n",
    "s = Student()\n",
    "s.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Create a Python class called `Rectangle` with a constructor that initializes the `width` and `height` attributes. Provide a method to calculate the area of the rectangle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Width: 10 units\n",
      "Height: 40 units\n",
      "Area: 400 sq. units\n"
     ]
    }
   ],
   "source": [
    "#defining the class\n",
    "class Rectangle:\n",
    "    #constructor that initializes the width and height\n",
    "    def __init__(self,width,height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "    #method to calculate the area\n",
    "    def area(self):\n",
    "        return self.width*self.height\n",
    "#creating an object of the class\n",
    "r = Rectangle(10,40)\n",
    "print(\"Width:\", r.width,\"units\")\n",
    "print(\"Height:\", r.height,\"units\")\n",
    "area = r.area()\n",
    "print(\"Area:\",area,\"sq. units\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. How can you have multiple constructors in a Python class? Explain with an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can have multiple constructors in python by using positional arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dog\n",
      "cat\n",
      "4\n",
      "snake\n",
      "5\n",
      "Reptile\n"
     ]
    }
   ],
   "source": [
    "#for example\n",
    "class Animal:\n",
    "    def __init__(self, *args):\n",
    "        if len(args) == 1:\n",
    "            self.name = args[0]\n",
    "        elif len(args) == 2:\n",
    "            self.name = args[0]\n",
    "            self.age = args[1]\n",
    "        elif len(args) == 3:\n",
    "            self.name = args[0]\n",
    "            self.age = args[1]\n",
    "            self.type = args[2]\n",
    "a1 = Animal(\"dog\") #it has only one attribute name\n",
    "a2 = Animal(\"cat\",4) #it has 2 attributes name and age\n",
    "a3 = Animal(\"snake\",5,\"Reptile\") #it has all the three attributes name,age,type\n",
    "print(a1.name)\n",
    "print(a2.name)\n",
    "print(a2.age)\n",
    "print(a3.name)\n",
    "print(a3.age)\n",
    "print(a3.type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. What is method overloading, and how is it related to constructors in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two or more methods have the same name but different numbers of parameters or different types of parameters, or both. These methods are called overloaded methods and this is called method overloading.\n",
    "\n",
    "But in Python, if we define a method with the same name multiple times in a class, the last definition will overwrite the previous ones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constructors and Default Values:\n",
    "When working with constructors in Python, we can simulate method overloading by providing default values for parameters.\n",
    "This allows you to create instances of the class with different sets of parameters, and the constructor can handle the various cases based on the provided values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For object a:\n",
      "default_value\n",
      "default_value\n",
      "For object b:\n",
      "3\n",
      "default_value\n",
      "For object c:\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, param1=None, param2=None):\n",
    "        if param1 is not None and param2 is not None:\n",
    "            # Constructor with both parameters\n",
    "            self.attribute1 = param1\n",
    "            self.attribute2 = param2\n",
    "        elif param1 is not None:\n",
    "            # Constructor with only param1\n",
    "            self.attribute1 = param1\n",
    "            self.attribute2 = \"default_value\"\n",
    "        else:\n",
    "            # Default constructor\n",
    "            self.attribute1 = \"default_value\"\n",
    "            self.attribute2 = \"default_value\"\n",
    "a = MyClass()\n",
    "print(\"For object a:\")\n",
    "print(a.attribute1)\n",
    "print(a.attribute2)\n",
    "b= MyClass(3)\n",
    "print(\"For object b:\")\n",
    "print(b.attribute1)\n",
    "print(b.attribute2)\n",
    "c = MyClass(3,4)\n",
    "print(\"For object c:\")\n",
    "print(c.attribute1)\n",
    "print(c.attribute2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable-Length Argument Lists:\n",
    "Python also allows us to use variable-length argument lists, such as *args and **kwargs, which provide flexibility in handling a variable number of arguments.\n",
    "This can be used to create more versatile constructors that can handle different sets of parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For object a:\n",
      "default_value\n",
      "default_value\n",
      "For object b:\n",
      "3\n",
      "default_value\n",
      "For object c:\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, *args):\n",
    "        if len(args) == 2:\n",
    "            # Constructor with two arguments\n",
    "            self.attribute1 = args[0]\n",
    "            self.attribute2 = args[1]\n",
    "        elif len(args) == 1:\n",
    "            # Constructor with one argument\n",
    "            self.attribute1 = args[0]\n",
    "            self.attribute2 = \"default_value\"\n",
    "        else:\n",
    "            # Default constructor\n",
    "            self.attribute1 = \"default_value\"\n",
    "            self.attribute2 = \"default_value\"\n",
    "a = MyClass()\n",
    "print(\"For object a:\")\n",
    "print(a.attribute1)\n",
    "print(a.attribute2)\n",
    "b= MyClass(3)\n",
    "print(\"For object b:\")\n",
    "print(b.attribute1)\n",
    "print(b.attribute2)\n",
    "c = MyClass(3,4)\n",
    "print(\"For object c:\")\n",
    "print(c.attribute1)\n",
    "print(c.attribute2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12. Explain the use of the `super()` function in Python constructors. Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The super() function in Python is used to call a method from a parent class, allowing us to invoke the constructor or other methods defined in the parent class. This is particularly useful in inheritance scenarios where we want to extend the functionality of a base class while still using its constructor or methods.\n",
    "\n",
    "In the context of constructors, calling super().__init__() is commonly used to invoke the constructor of the parent class. This ensures that the initialization code in the parent class is executed before the initialization code in the child class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parent constructor called\n",
      "Child constructor called\n",
      "Name: Alice\n",
      "Age: 25\n"
     ]
    }
   ],
   "source": [
    "#Here's an example to illustrate the use of super() in a Python constructor:\n",
    "class Parent:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        print(\"Parent constructor called\")\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}\")\n",
    "\n",
    "class Child(Parent):\n",
    "    def __init__(self, name, age):\n",
    "        # Calling the constructor of the parent class using super()\n",
    "        super().__init__(name)\n",
    "        self.age = age\n",
    "        print(\"Child constructor called\")\n",
    "\n",
    "    def display_info(self):\n",
    "        # Calling a method from the parent class using super()\n",
    "        super().display_info()\n",
    "        print(f\"Age: {self.age}\")\n",
    "\n",
    "# Creating an instance of the Child class\n",
    "child_obj = Child(\"Alice\", 25)\n",
    "\n",
    "# Calling the display_info method on the Child object\n",
    "child_obj.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13. Create a class called `Book` with a constructor that initializes the `title`, `author`, and `published_year`attributes. Provide a method to display book details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book details:\n",
      "Title: Let us C\n",
      "Author: Y.Kanetkar\n",
      "Published year: 1995\n"
     ]
    }
   ],
   "source": [
    "#creating the class Book\n",
    "class Book:\n",
    "    #constructor to initialize the attributes\n",
    "    def __init__(self,title,author,py):\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "        self.published_year = py\n",
    "        \n",
    "    #method to display the details\n",
    "    def disp_details(self):\n",
    "        print(\"Book details:\")\n",
    "        print(\"Title:\",self.title)\n",
    "        print(\"Author:\",self.author)\n",
    "        print(\"Published year:\",self.published_year)\n",
    "#creating object of the class Book by initializing the attributes\n",
    "book1 = Book(\"Let us C\",\"Y.Kanetkar\",1995)\n",
    "#calling the method to display the details\n",
    "book1.disp_details()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 14. Discuss the differences between constructors and regular methods in Python classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Difference between constructors and regular methods are:\n",
    "# Initialization vs. General Functionality:\n",
    "\n",
    "## Constructors: \n",
    "Constructors are special methods used for initializing the attributes of an object when it is created. They are typically named __init__ and are called automatically when an object is instantiated.\n",
    "## Regular Methods: \n",
    "Regular methods are used for general functionality within a class. They can perform various operations and may or may not modify the object's attributes.\n",
    "\n",
    "# Automatic Invocation:\n",
    "\n",
    "## Constructors:\n",
    "Constructors are automatically invoked when an object is created from a class. They set up the initial state of the object.\n",
    "## Regular Methods: \n",
    "Regular methods need to be called explicitly on an instance of the class. They are not automatically invoked during object creation.\n",
    "\n",
    "# Return Value:\n",
    "\n",
    "## Constructors: \n",
    "Constructors do not have a return statement by convention. They focus on initializing attributes, and the constructed object is returned implicitly.\n",
    "## Regular Methods:\n",
    "Regular methods may or may not have a return statement. They can perform operations and return values as needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book details:\n",
      "Title: Let us C\n",
      "Author: Y.Kanetkar\n",
      "Published year: 1995\n"
     ]
    }
   ],
   "source": [
    "#eg:\n",
    "\n",
    "class Book:\n",
    "    #constructor \n",
    "    def __init__(self,title,author,py):\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "        self.published_year = py\n",
    "        \n",
    "    #regular method\n",
    "    def disp_details(self):\n",
    "        print(\"Book details:\")\n",
    "        print(\"Title:\",self.title)\n",
    "        print(\"Author:\",self.author)\n",
    "        print(\"Published year:\",self.published_year)\n",
    "#constructor is automatically invoked when the object is created\n",
    "book1 = Book(\"Let us C\",\"Y.Kanetkar\",1995)\n",
    "#calling the method to display the details\n",
    "book1.disp_details()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15. Explain the role of the `self` parameter in instance variable initialization within a constructor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The self parameter in a constructor plays a crucial role in initializing instance variables. The self parameter is a reference to the instance of the class, and it is used to differentiate between instance variables and local variables within a method. This allows us to access and manipulate the attributes of the object being created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, attribute1, attribute2):\n",
    "        # Using 'self' to initialize instance variables\n",
    "        self.attribute1 = attribute1\n",
    "        self.attribute2 = attribute2\n",
    "\n",
    "# Creating an instance of MyClass\n",
    "obj = MyClass(\"value1\", \"value2\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 16. How do you prevent a class from having multiple instances by using constructors in Python? Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can prevent a class from having multiple instances by using constructors in Python by using the `__new__` method. The `__new__` method is called before the `__init__` method, and it can be used to create a new instance of the class or to prevent the creation of a new instance.\n",
    "To prevent the creation of a new instance, you can raise an exception in the `__new__` method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "Exception",
     "evalue": "Cannot create new instances of MyClass",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_17492\\3251261547.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__new__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m         \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Cannot create new instances of MyClass\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mMyClass\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_17492\\3251261547.py\u001b[0m in \u001b[0;36m__new__\u001b[1;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mclass\u001b[0m \u001b[0mMyClass\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__new__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Cannot create new instances of MyClass\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mMyClass\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mException\u001b[0m: Cannot create new instances of MyClass"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        raise Exception(\"Cannot create new instances of MyClass\")\n",
    "c = MyClass()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 17. Create a Python class called `Student` with a constructor that takes a list of subjects as a parameter and initializes the `subjects` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Subjects for Student 1: ['Math', 'Science', 'English']\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, subjects):\n",
    "        self.subjects = subjects\n",
    "\n",
    "# Creating an instance of the Student class with a list of subjects\n",
    "student1 = Student([\"Math\", \"Science\", \"English\"])\n",
    "\n",
    "# Accessing the subjects attribute\n",
    "print(\"Subjects for Student 1:\", student1.subjects)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 18. What is the purpose of the `__del__` method in Python classes, and how does it relate to constructors?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `__del__` method in Python is a special method, sometimes referred to as a destructor. It is called when an object is about to be destroyed or garbage-collected, i.e., when there are no more references to the object. The primary purpose of the `__del__` method is to perform any cleanup or resource release actions before the object is removed from memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Object 1 created\n",
      "Object 2 created\n",
      "Object 1 destroyed\n",
      "Object 2 destroyed\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        print(f\"{self.name} created\")\n",
    "\n",
    "    def __del__(self):\n",
    "        print(f\"{self.name} destroyed\")\n",
    "\n",
    "# Creating instances of MyClass\n",
    "obj1 = MyClass(\"Object 1\")\n",
    "obj2 = MyClass(\"Object 2\")\n",
    "\n",
    "# Deliberately deleting references to the objects\n",
    "del obj1\n",
    "del obj2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 19. Explain the use of constructor chaining in Python. Provide a practical example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constructor chaining in Python refers to the concept of one constructor calling another constructor within the same class. This is achieved using the super() function to invoke the constructor of the parent class. Constructor chaining is useful when we have multiple constructors with different parameter lists, and we want to avoid duplicating the initialization logic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person constructor called\n",
      "Student constructor called\n",
      "Name: Alice, Age: 20\n",
      "Student ID: S12345\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        print(\"Person constructor called\")\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}, Age: {self.age}\")\n",
    "\n",
    "class Student(Person):\n",
    "    def __init__(self, name, age, student_id):\n",
    "        # Call the constructor of the parent class using super()\n",
    "        super().__init__(name, age)\n",
    "        \n",
    "        # Initialize additional attributes specific to Student\n",
    "        self.student_id = student_id\n",
    "        print(\"Student constructor called\")\n",
    "\n",
    "    def display_student_info(self):\n",
    "        # Call a method from the parent class using super()\n",
    "        super().display_info()\n",
    "        print(f\"Student ID: {self.student_id}\")\n",
    "\n",
    "# Creating an instance of the Student class\n",
    "student = Student(\"Alice\", 20, \"S12345\")\n",
    "\n",
    "# Calling methods on the Student object\n",
    "student.display_student_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 20. Create a Python class called `Car` with a default constructor that initializes the `make` and `model`attributes. Provide a method to display car information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car information: Make-some data, Model-Bolero\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    def __init__(self):\n",
    "        #default constructor that initializes the make and model attributes.\n",
    "        self.make = \"some data\"\n",
    "        self.model = \"Bolero\"\n",
    "    def display(self):\n",
    "        print(f\"Car information: Make-{self.make}, Model-{self.model}\")\n",
    "    \n",
    "car1 = Car()\n",
    "car1.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inheritance:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. What is inheritance in Python? Explain its significance in object-oriented programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inheritance in Python is a fundamental concept of object-oriented programming (OOP) that allows a class (called the subclass or derived class) to inherit attributes and methods from another class (called the superclass or base class). The subclass can then extend or override the inherited functionality, providing a way to model a \"is-a\" relationship between classes.\n",
    "\n",
    "Here are some of the benefits of inheritance:\n",
    "## Code reuse:\n",
    "Inheritance allows us to reuse code from existing classes, which can save you time and effort.\n",
    "## Reduced complexity:\n",
    "Inheritance can help to reduce the complexity of our code by allowing us to organize it into a hierarchy of classes.\n",
    "## Increased flexibility:\n",
    "Inheritance can make our code more flexible by allowing us to easily add new features to existing classes.\n",
    "## Improved readability:\n",
    "Inheritance can make our code more readable by allowing us to group related code together into classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape is red.\n",
      "The shape is blue.\n",
      "The area of the square is 16 square units.\n"
     ]
    }
   ],
   "source": [
    "# example\n",
    "\n",
    "# Base class (superclass)\n",
    "class Shape:\n",
    "    def __init__(self, color):\n",
    "        self.color = color\n",
    "\n",
    "    def display_color(self):\n",
    "        print(f\"The shape is {self.color}.\")\n",
    "\n",
    "# Derived class (subclass) inheriting from Shape\n",
    "class Square(Shape):\n",
    "    def __init__(self, color, side_length):\n",
    "        # Call the constructor of the base class using super()\n",
    "        super().__init__(color)\n",
    "        self.side_length = side_length\n",
    "\n",
    "    def display_area(self):\n",
    "        area = self.side_length ** 2\n",
    "        print(f\"The area of the square is {area} square units.\")\n",
    "\n",
    "# Creating instances of the classes\n",
    "shape = Shape(\"red\")\n",
    "square = Square(\"blue\", 4)\n",
    "\n",
    "# Calling methods on instances\n",
    "shape.display_color()  \n",
    "square.display_color() \n",
    "square.display_area()  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Differentiate between single inheritance and multiple inheritance in Python. Provide examples for each."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single Inheritance:\n",
    "\n",
    "In single inheritance, a class can inherit from only one superclass. This means that a derived class (subclass) can have only one immediate parent class (superclass)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generic animal sound\n",
      "Woof!\n"
     ]
    }
   ],
   "source": [
    "# Single Inheritance Example\n",
    "\n",
    "# Base class (superclass)\n",
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Generic animal sound\")\n",
    "\n",
    "# Derived class (subclass) inheriting from Animal\n",
    "class Dog(Animal):\n",
    "    def bark(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "# Creating an instance of the derived class\n",
    "dog = Dog()\n",
    "\n",
    "# Calling methods on the instance\n",
    "dog.speak()  \n",
    "dog.bark()   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Inheritance:\n",
    "\n",
    "In multiple inheritance, a class can inherit from more than one superclass. This means that a derived class can have multiple immediate parent classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generic animal sound\n",
      "Giving birth to live young\n",
      "Woof!\n"
     ]
    }
   ],
   "source": [
    "# Multiple Inheritance Example\n",
    "\n",
    "# Base class 1 (superclass)\n",
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Generic animal sound\")\n",
    "\n",
    "# Base class 2 (superclass)\n",
    "class Mammal:\n",
    "    def give_birth(self):\n",
    "        print(\"Giving birth to live young\")\n",
    "\n",
    "# Derived class (subclass) inheriting from Animal and Mammal\n",
    "class Dog(Animal, Mammal):\n",
    "    def bark(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "# Creating an instance of the derived class\n",
    "dog = Dog()\n",
    "\n",
    "# Calling methods on the instance\n",
    "dog.speak()        \n",
    "dog.give_birth()   \n",
    "dog.bark()         \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the Dog class inherits from both the Animal and Mammal classes, demonstrating multiple inheritance. The Dog class has access to methods from both parent classes, allowing it to exhibit characteristics of both animals and mammals."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Create a Python class called `Vehicle` with attributes `color` and `speed`. Then, create a child class called `Car` that inherits from `Vehicle` and adds a `brand` attribute. Provide an example of creating a `Car` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Color: Red, Speed: 333\n",
      "Brand: Audi\n"
     ]
    }
   ],
   "source": [
    "#parent class\n",
    "class Vehicle:\n",
    "    def __init__(self,color,speed):\n",
    "        self.color = color\n",
    "        self.speed = speed\n",
    "    def display(self):\n",
    "        print(f\"Color: {self.color}, Speed: {self.speed}\")\n",
    "#Inherited/child class\n",
    "class Car(Vehicle):\n",
    "    def __init__(self,color,speed,brand):\n",
    "        super().__init__(color,speed)\n",
    "        self.brand = brand\n",
    "    def display(self):\n",
    "        super().display()\n",
    "        print(f\"Brand: {self.brand}\")\n",
    "        \n",
    "car1 = Car(\"Red\",333,\"Audi\")\n",
    "car1.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Explain the concept of method overriding in inheritance. Provide a practical example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method overriding is a concept in object-oriented programming that allows a subclass to provide a specific implementation of a method that is already defined in its superclass. When a method in the subclass has the same name, parameters, and return type as a method in the superclass, the method in the subclass overrides the method in the superclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is method of child class\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "\n",
    "##parent class\n",
    "class Parent:\n",
    "    def say(self):\n",
    "        print(\"This is method of parent class\")\n",
    "        \n",
    "##inherited class\n",
    "class Child(Parent):\n",
    "    def say(self):\n",
    "        print(\"This is method of child class\")\n",
    "\n",
    "#object of inherited class\n",
    "c1 = Child()\n",
    "c1.say() #method of child class is called instead of parent class\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. How can you access the methods and attributes of a parent class from a child class in Python? Give an example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, we can access the methods and attributes of a parent class from a child class using the `super()` function. The `super()` function provides a way to call methods and access attributes from the parent class within the context of the child class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Color: Red, Speed: 333\n",
      "Brand: Audi\n"
     ]
    }
   ],
   "source": [
    "#Example:\n",
    "\n",
    "#parent class\n",
    "class Vehicle:\n",
    "    def __init__(self,color,speed):\n",
    "        self.color = color\n",
    "        self.speed = speed\n",
    "    def display(self):\n",
    "        print(f\"Color: {self.color}, Speed: {self.speed}\")\n",
    "#Inherited/child class\n",
    "class Car(Vehicle):\n",
    "    def __init__(self,color,speed,brand):\n",
    "        super().__init__(color,speed) #using super() to access the constructor of parent class\n",
    "        self.brand = brand\n",
    "    def display(self):\n",
    "        super().display() #using super() to access the method of parent class\n",
    "        print(f\"Brand: {self.brand}\")\n",
    "        \n",
    "car1 = Car(\"Red\",333,\"Audi\")\n",
    "car1.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Discuss the use of the `super()` function in Python inheritance. When and why is it used? Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `super()` function in Python is used in the context of inheritance to call methods and access attributes of a superclass (parent class) from a subclass (child class). It is particularly useful when you want to extend or override the behavior of methods in the subclass while still utilizing the functionality defined in the superclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Color: Red, Speed: 333\n",
      "Brand: Audi\n"
     ]
    }
   ],
   "source": [
    "#Example:\n",
    "\n",
    "#parent class\n",
    "class Vehicle:\n",
    "    def __init__(self,color,speed):\n",
    "        self.color = color\n",
    "        self.speed = speed\n",
    "    def display(self):\n",
    "        print(f\"Color: {self.color}, Speed: {self.speed}\")\n",
    "#Inherited/child class\n",
    "class Car(Vehicle):\n",
    "    def __init__(self,color,speed,brand):\n",
    "        super().__init__(color,speed) #using super() to access the constructor of parent class\n",
    "        self.brand = brand\n",
    "    def display(self):\n",
    "        super().display() #using super() to access the method of parent class\n",
    "        print(f\"Brand: {self.brand}\")\n",
    "        \n",
    "car1 = Car(\"Red\",333,\"Audi\")\n",
    "car1.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Create a Python class called `Animal` with a method `speak()`. Then, create child classes `Dog` and `Cat` that inherit from `Animal` and override the `speak()` method. Provide an example of using these classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random animal sound\n",
      "Bark!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Random animal sound\")\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Bark!\")\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Meow!\")\n",
    "a = Animal()\n",
    "a.speak()\n",
    "b = Dog()\n",
    "b.speak()\n",
    "c =Cat()\n",
    "c.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Explain the role of the `isinstance()` function in Python and how it relates to inheritance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `isinstance()` function in Python is used to check if an object belongs to a particular class or a tuple of classes. It returns True if the object is an instance of any of the specified classes, and False otherwise.\n",
    "\n",
    "The general syntax of isinstance() is as follows:\n",
    "isinstance(object, classinfo)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Role of isinstance() in Relation to Inheritance:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking Instance of a Specific Class:\n",
    "we can use isinstance() to check if an object is an instance of a specific class, including its subclasses. This is useful for testing the type of an object in the context of inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "\n",
    "class Animal:\n",
    "    pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    pass\n",
    "\n",
    "my_dog = Dog()\n",
    "\n",
    "print(isinstance(my_dog, Animal))  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Polymorphic Behavior:\n",
    "`isinstance()` is often used in scenarios where polymorphism is desired. Polymorphism allows objects of different classes to be treated as objects of a common base class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of square\n",
      "Area of circle\n"
     ]
    }
   ],
   "source": [
    "#Example\n",
    "\n",
    "class Shape:\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "class Square(Shape):\n",
    "    def area(self):\n",
    "        return \"Area of square\"\n",
    "\n",
    "class Circle(Shape):\n",
    "    def area(self):\n",
    "        return \"Area of circle\"\n",
    "\n",
    "my_square = Square()\n",
    "my_circle = Circle()\n",
    "\n",
    "shapes = [my_square, my_circle]\n",
    "\n",
    "for shape in shapes:\n",
    "    if isinstance(shape, Shape):\n",
    "        print(shape.area())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. What is the purpose of the `issubclass()` function in Python? Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The issubclass() function in Python is used to check if a class is a subclass of another class. It returns True if the first class is a subclass of the second class, and False otherwise.\n",
    "\n",
    "The general syntax of issubclass() is as follows:\n",
    "issubclass(class, classinfo)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#For example\n",
    "class Animal:\n",
    "    pass\n",
    "\n",
    "class Mammal(Animal):\n",
    "    pass\n",
    "\n",
    "class Dog(Mammal):\n",
    "    pass\n",
    "\n",
    "# Checking subclass relationship\n",
    "print(issubclass(Mammal, Animal))  \n",
    "print(issubclass(Dog, Mammal))     \n",
    "print(issubclass(Dog, Animal))     \n",
    "print(issubclass(Animal, Dog))     \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Discuss the concept of constructor inheritance in Python. How are constructors inherited in child classes?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, constructor inheritance refers to the process by which a child class inherits the constructor of its parent class. The constructor is a special method in a class that is called when an object of that class is instantiated. It is typically named `__init__` in Python.\n",
    "\n",
    "When we create a child class, it can inherit the constructor of its parent class, and we can choose to extend or override the behavior of the parent class constructor in the child class. The child class can have its own constructor, and it can call the constructor of the parent class using the super() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Color: Red, Speed: 333\n",
      "Brand: Audi\n"
     ]
    }
   ],
   "source": [
    "#Example:\n",
    "\n",
    "#parent class\n",
    "class Vehicle:\n",
    "    #parent class constructor\n",
    "    def __init__(self,color,speed):\n",
    "        self.color = color\n",
    "        self.speed = speed\n",
    "    def display(self):\n",
    "        print(f\"Color: {self.color}, Speed: {self.speed}\")\n",
    "#Inherited/child class\n",
    "class Car(Vehicle):\n",
    "    #child class constructor\n",
    "    def __init__(self,color,speed,brand):\n",
    "        super().__init__(color,speed) #using super() to access the constructor of parent class\n",
    "        self.brand = brand\n",
    "    def display(self):\n",
    "        super().display() #using super() to access the method of parent class\n",
    "        print(f\"Brand: {self.brand}\")\n",
    "        \n",
    "car1 = Car(\"Red\",333,\"Audi\")\n",
    "car1.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. 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 accordingly. Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is area of the shape\n",
      "Area of circle: 78.5 unit sq\n",
      "Area of the rectangle is: 30 unit sq\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    def area(self):\n",
    "        print(\"This is area of the shape\")\n",
    "\n",
    "        \n",
    "class Circle(Shape):\n",
    "    def __init__(self,radius):\n",
    "        self.radius = radius\n",
    "    def area(self):\n",
    "        print(\"Area of circle:\",3.14*self.radius**2,\"unit sq\")\n",
    "\n",
    "        \n",
    "class Rectancle(Shape):\n",
    "    def __init__(self,length,width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "    def area(self):\n",
    "        print(\"Area of the rectangle is:\",self.length*self.width,\"unit sq\")\n",
    "\n",
    "obj1 = Shape()\n",
    "obj1.area()\n",
    "obj2 = Circle(5)\n",
    "obj2.area()\n",
    "obj3 = Rectancle(5,6)\n",
    "obj3.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12. Explain the use of abstract base classes (ABCs) in Python and how they relate to inheritance. Provide an example using the `abc` module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main goal of the abstract base class is to provide a standardized way to test whether an object adheres to a given specification. It can also prevent any attempt to instantiate a subclass that doesn’t override a particular method in the superclass. And finally, using an abstract class, a class can derive identity from another class without any object inheritance.The abc module in Python provides the infrastructure for creating abstract base classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the circle: 78.5\n",
      "Perimeter of the circle: 31.400000000000002\n",
      "Area of the rectangle: 24\n",
      "Perimeter of the rectangle: 20\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Define an abstract base class called Shape\n",
    "class Shape(ABC):\n",
    "\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def perimeter(self):\n",
    "        pass\n",
    "\n",
    "# Create a concrete class Circle that inherits from Shape\n",
    "class Circle(Shape):\n",
    "\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return 3.14 * self.radius**2\n",
    "\n",
    "    def perimeter(self):\n",
    "        return 2 * 3.14 * self.radius\n",
    "\n",
    "# Create another concrete class Rectangle that inherits from Shape\n",
    "class Rectangle(Shape):\n",
    "\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",
    "    def perimeter(self):\n",
    "        return 2 * (self.length + self.width)\n",
    "\n",
    "# Instantiate objects of the concrete classes\n",
    "circle = Circle(radius=5)\n",
    "rectangle = Rectangle(length=4, width=6)\n",
    "\n",
    "# Call the area and perimeter methods on the objects\n",
    "print(\"Area of the circle:\", circle.area())\n",
    "print(\"Perimeter of the circle:\", circle.perimeter())\n",
    "print(\"Area of the rectangle:\", rectangle.area())\n",
    "print(\"Perimeter of the rectangle:\", rectangle.perimeter())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Can't instantiate abstract class Rectangle with abstract methods area, perimeter",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_10332\\258891719.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     45\u001b[0m \u001b[1;31m# Instantiate objects of the concrete classes\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     46\u001b[0m \u001b[0mcircle\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mCircle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mradius\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 47\u001b[1;33m \u001b[0mrectangle\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mRectangle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlength\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mwidth\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     48\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     49\u001b[0m \u001b[1;31m# Call the area and perimeter methods on the objects\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: Can't instantiate abstract class Rectangle with abstract methods area, perimeter"
     ]
    }
   ],
   "source": [
    "'''If a class does not provide concrete implementations \n",
    "for all the abstract methods of its abstract base class,\n",
    "attempting to instantiate it will raise a TypeError.'''\n",
    "\n",
    "#example\n",
    "\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Define an abstract base class called Shape\n",
    "class Shape(ABC):\n",
    "\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def perimeter(self):\n",
    "        pass\n",
    "\n",
    "# Create a concrete class Circle that inherits from Shape\n",
    "class Circle(Shape):\n",
    "\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return 3.14 * self.radius**2\n",
    "\n",
    "    def perimeter(self):\n",
    "        return 2 * 3.14 * self.radius\n",
    "\n",
    "# Create another concrete class Rectangle that inherits from Shape\n",
    "class Rectangle(Shape):\n",
    "\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",
    "#     def perimeter(self):\n",
    "#         return 2 * (self.length + self.width)\n",
    "\n",
    "# Instantiate objects of the concrete classes\n",
    "circle = Circle(radius=5)\n",
    "rectangle = Rectangle(length=4, width=6)\n",
    "\n",
    "# Call the area and perimeter methods on the objects\n",
    "print(\"Area of the circle:\", circle.area())\n",
    "print(\"Perimeter of the circle:\", circle.perimeter())\n",
    "print(\"Area of the rectangle:\", rectangle.area())\n",
    "print(\"Perimeter of the rectangle:\", rectangle.perimeter())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13. How can you prevent a child class from modifying certain attributes or methods inherited from a parent class in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use Private or Protected Attributes/Methods:\n",
    "\n",
    "Make the attributes or methods in the parent class private (by prefixing them with a double underscore `__)` or protected (by prefixing them with a single underscore `_)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "class Parent:\n",
    "    def __init__(self):\n",
    "        self.__private_attribute = 42\n",
    "        self._protected_attribute = \"Hello\"\n",
    "\n",
    "    def __private_method(self):\n",
    "        print(\"This is a private method.\")\n",
    "\n",
    "    def _protected_method(self):\n",
    "        print(\"This is a protected method.\")\n",
    "\n",
    "class Child(Parent):\n",
    "    def access_parent_attributes(self):\n",
    "        # The child class can still access private and protected attributes\n",
    "        print(self._protected_attribute)\n",
    "\n",
    "        # However, it's a convention not to modify them directly\n",
    "        # self._protected_attribute = \"Modified\"  # Avoid doing this\n",
    "\n",
    "# Example usage\n",
    "child_obj = Child()\n",
    "child_obj.access_parent_attributes()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Override and Raise an Exception:\n",
    "\n",
    "If we want to explicitly prevent modification of a specific attribute or method, we can override it in the child class and raise an exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "Modification of protected attribute is not allowed.",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_10332\\3681266774.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mChild\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 15\u001b[1;33m \u001b[0mc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmodify_protected_attribute\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m55\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_10332\\3681266774.py\u001b[0m in \u001b[0;36mmodify_protected_attribute\u001b[1;34m(self, new_value)\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;32mclass\u001b[0m \u001b[0mChild\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mParent\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mmodify_protected_attribute\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_value\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Modification of protected attribute is not allowed.\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mChild\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: Modification of protected attribute is not allowed."
     ]
    }
   ],
   "source": [
    "#example:\n",
    "\n",
    "class Parent:\n",
    "    def __init__(self):\n",
    "        self.protected_attribute = \"Hello\"\n",
    "\n",
    "    def modify_protected_attribute(self, new_value):\n",
    "        self.protected_attribute = new_value\n",
    "\n",
    "class Child(Parent):\n",
    "    def modify_protected_attribute(self, new_value):\n",
    "        raise AttributeError(\"Modification of protected attribute is not allowed.\")\n",
    "\n",
    "c = Child()\n",
    "c.modify_protected_attribute(55)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 14. Create a Python class called `Employee` with attributes `name` and `salary`. Then, create a child class `Manager` that inherits from `Employee` and adds an attribute `department`. Provide an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Rahul\n",
      "Salary: 85000\n",
      "Department: HR\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    def __init__(self,name,salary):\n",
    "        self.name = name\n",
    "        self.salary = salary\n",
    "\n",
    "class Manager(Employee):\n",
    "    def __init__(self,name,salary,department):\n",
    "        super().__init__(name,salary)\n",
    "        self.department = department\n",
    "\n",
    "man = Manager(\"Rahul\",85000,\"HR\")\n",
    "print(\"Name:\",man.name)\n",
    "print(\"Salary:\",man.salary)\n",
    "print(\"Department:\",man.department)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15. Discuss the concept of method overloading in Python inheritance. How does it differ from method overriding?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Method overloading` in Python inheritance is the ability to have multiple methods with the same name but different parameter lists. This allows for a more flexible and reusable codebase, as developers can use the same method name for different tasks without having to create new methods.\n",
    "\n",
    "`Method overriding` in Python inheritance is the ability to redefine a method in a subclass that has the same name as a method in its superclass. This allows for a more specialized implementation of the method in the subclass, as the subclass can take advantage of its own specific properties and functionality.\n",
    "\n",
    "The main difference between method overloading and method overriding is that method overloading is done within a class, while method overriding is done between a subclass and its superclass. Additionally, method overloading is not directly supported by Python, while method overriding is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm a dog!\n",
      "I'm a cat!\n"
     ]
    }
   ],
   "source": [
    "#for example:\n",
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"I'm an animal!\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        print(\"I'm a dog!\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        print(\"I'm a cat!\")\n",
    "\n",
    "# Create a dog and a cat object\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "# Call the speak() method on the dog and cat objects\n",
    "dog.speak()\n",
    "cat.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the `speak()` method is `overloaded` in the Animal class to allow for different implementations in the Dog and Cat subclasses. This allows for a more flexible and reusable codebase, as developers can use the same method name for different tasks without having to create new methods.\n",
    "\n",
    "the `speak()` method is `overridden` in the Dog and Cat subclasses to provide more specialized implementations. This allows for a more flexible and reusable codebase, as developers can use the same method name for different tasks without having to create new methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 16. Explain the purpose of the `__init__()` method in Python inheritance and how it is utilized in child classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `__init__()` method in Python is a special method, also known as the constructor. It is automatically called when an object of a class is created. The primary purpose of the `__init__()` method is to initialize the attributes of the object.\n",
    "\n",
    "In the context of inheritance, when a class serves as a parent class (or superclass), the `__init__()` method is often used to initialize attributes that are common to all instances of the class. When a child class inherits from a parent class, it can extend or override the behavior of the `__init__()` method to include its own attributes or to customize the initialization process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Rahul\n",
      "Salary: 85000\n",
      "Department: HR\n"
     ]
    }
   ],
   "source": [
    "#for example:\n",
    "\n",
    "class Employee:\n",
    "    def __init__(self,name,salary):\n",
    "        self.name = name\n",
    "        self.salary = salary\n",
    "\n",
    "class Manager(Employee):\n",
    "    def __init__(self,name,salary,department):\n",
    "        #calling the __init__() method of the parent class to initialize the values.\n",
    "        super().__init__(name,salary)\n",
    "        self.department = department\n",
    "\n",
    "man = Manager(\"Rahul\",85000,\"HR\")\n",
    "print(\"Name:\",man.name)\n",
    "print(\"Salary:\",man.salary)\n",
    "print(\"Department:\",man.department)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 17. 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 classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All birds can fly!\n",
      "I am Eagle and I can fly!\n",
      "I am Sparrow and I can fly!\n"
     ]
    }
   ],
   "source": [
    "class Bird:\n",
    "    def fly(self):\n",
    "        print(\"All birds can fly!\")\n",
    "\n",
    "class Eagle(Bird):\n",
    "    def fly(self):\n",
    "        print(\"I am Eagle and I can fly!\")\n",
    "\n",
    "class Sparrow(Bird):\n",
    "    def fly(self):\n",
    "        print(\"I am Sparrow and I can fly!\")\n",
    "        \n",
    "\n",
    "b1 = Bird()\n",
    "b1.fly()\n",
    "b2 = Eagle()\n",
    "b2.fly()\n",
    "b3 = Sparrow()\n",
    "b3.fly()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 18. What is the \"diamond problem\" in multiple inheritance, and how does Python address it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `\"diamond problem\"` is a term used in the context of object-oriented programming and multiple inheritance. It refers to the potential ambiguity that arises when a class inherits from two classes that have a common ancestor. This results in a diamond-shaped inheritance hierarchy, and issues can arise when methods or attributes are overridden or accessed through the hierarchy.\n",
    "\n",
    "For example:\n",
    "\n",
    "     `A\n",
    "     / \\\n",
    "    B   C\n",
    "     \\ /\n",
    "      D`\n",
    "\n",
    "In this diagram, class D inherits from both classes B and C, which in turn both inherit from class A. Now, if there is a method or attribute in class A that is overridden in both B and C, and class D tries to access it, there can be ambiguity about which overridden version of the method or attribute to use.The diamond problem can lead to confusion and errors in the code.\n",
    "In Python, the language provides a solution through a mechanism called C3 linearization or C3 superclass linearization. This algorithm ensures a consistent and predictable order in which base classes are considered during method resolution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method in class B\n"
     ]
    }
   ],
   "source": [
    "#for example:\n",
    "class A:\n",
    "    def method(self):\n",
    "        print(\"Method in class A\")\n",
    "\n",
    "class B(A):\n",
    "    def method(self):\n",
    "        print(\"Method in class B\")\n",
    "\n",
    "class C(A):\n",
    "    def method(self):\n",
    "        print(\"Method in class C\")\n",
    "\n",
    "class D(B, C):\n",
    "    pass\n",
    "\n",
    "# Example usage\n",
    "obj_d = D()\n",
    "obj_d.method()\n",
    "\n",
    "#In this case, the MRO is [D, B, C, A], \n",
    "#so the method from class B is the one that gets called.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 19. Discuss the concept of \"is-a\" and \"has-a\" relationships in inheritance, and provide examples of each."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \"Is-a\" Relationship:\n",
    "\n",
    "An \"is-a\" relationship represents inheritance, where a subclass is considered to be a specialization or subtype of its superclass. In other words, if class A is a subclass of class B, it means that objects of class A \"are-a\" kind of objects of class B."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"Is-a\" relationship\n",
    "class Animal:\n",
    "    def make_sound(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Bark bark!\")\n",
    "#Here, Dog is a subclass of Animal,\n",
    "#and a Dog \"is-a\" kind of Animal. The Dog class inherits the behavior of the Animal class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \"Has-a\" Relationship:\n",
    "\n",
    "A \"has-a\" relationship represents composition, where one class has an instance of another class as a part of its implementation. This is often implemented using instance variables, and it signifies that an object of one class \"has-a\" part that is an object of another class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"Has-a\" relationship\n",
    "class Engine:\n",
    "    def start(self):\n",
    "        print(\"Engine started\")\n",
    "\n",
    "class Car:\n",
    "    def __init__(self):\n",
    "        self.engine = Engine()\n",
    "\n",
    "    def start(self):\n",
    "        print(\"Car starting...\")\n",
    "        self.engine.start()\n",
    "\n",
    "#In this example, a Car \"has-a\" relationship with an Engine. \n",
    "#The Car class has an instance variable engine of type Engine,\n",
    "#representing the fact that a car has an engine as a part of its composition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 20. Create a Python class hierarchy for a university system. Start with a base class `Person` and create child classes `Student` and `Professor`, each with their own attributes and methods. Provide an example of using these classes in a university context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul enrolled in Mathematics\n",
      "Rahul enrolled in Data Science\n",
      "Professor Dr.P.R Sharma assigned to teach Data science\n",
      "Professor Dr.P.R Sharma assigned to teach Machine learning\n",
      "Student details:\n",
      "\n",
      "\n",
      "Name: Rahul, Age: 20, sex: M \n",
      "Student ID: S123, Courses: Mathematics, Data Science\n",
      "Professor details:\n",
      "\n",
      "\n",
      "Name: Dr.P.R Sharma, Age: 55, sex: M \n",
      "Employee ID: E292, Courses Taught: Data science, Machine learning\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,name,age,sex):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.sex = sex\n",
    "    \n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}, Age: {self.age}, sex: {self.sex} \")\n",
    "\n",
    "class Student(Person):\n",
    "    def __init__(self,name,age,sex,student_id):\n",
    "        super().__init__(name,age,sex)\n",
    "        self.student_id = student_id\n",
    "        self.courses = []\n",
    "    def enroll(self,course):\n",
    "        self.courses.append(course)\n",
    "        print(f\"{self.name} enrolled in {course}\")\n",
    "    def display_info(self):\n",
    "        super().display_info()\n",
    "        print(f\"Student ID: {self.student_id}, Courses: {', '.join(self.courses)}\")\n",
    "        \n",
    "        \n",
    "class Professor(Person):\n",
    "    def __init__(self, name, age,sex, employee_id):\n",
    "        super().__init__(name, age,sex)\n",
    "        self.employee_id = employee_id\n",
    "        self.courses_taught = []\n",
    "\n",
    "    def assign_course(self, course):\n",
    "        self.courses_taught.append(course)\n",
    "        print(f\"Professor {self.name} assigned to teach {course}\")\n",
    "\n",
    "    def display_info(self):\n",
    "        super().display_info()\n",
    "        print(f\"Employee ID: {self.employee_id}, Courses Taught: {', '.join(self.courses_taught)}\")\n",
    "        \n",
    "student1 = Student(\"Rahul\",20,'M',\"S123\")\n",
    "student1.enroll(\"Mathematics\")\n",
    "student1.enroll(\"Data Science\")\n",
    "\n",
    "prof = Professor(\"Dr.P.R Sharma\",55,'M',\"E292\")\n",
    "prof.assign_course(\"Data science\")\n",
    "prof.assign_course(\"Machine learning\")\n",
    "\n",
    "print(\"Student details:\\n\\n\")\n",
    "student1.display_info()\n",
    "\n",
    "print(\"Professor details:\\n\\n\")\n",
    "prof.display_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Encapsulation:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Explain the concept of encapsulation in Python. What is its role in object-oriented programming?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encapsulation is one of the key concepts of object-oriented programming (OOP). It is the process of bundling data and methods into a single unit, called a class. This unit is then treated as a black box, with only its public methods exposed to the outside world.\n",
    "The main benefit of encapsulation is that it helps to protect the data and methods of a class from accidental or malicious modification. This is because only the class's own methods can access its data, so external code cannot change it without going through the class's methods. This helps to make the class more robust and secure.\n",
    "Encapsulation also helps to promote code reuse. When data and methods are bundled together into a class, they can be easily reused in other classes. This helps to reduce the amount of code that needs to be written, and can make it easier to maintain and update the code.\n",
    "In Python, encapsulation is implemented using the private and protected access modifiers. Private variables and methods are only accessible from within the class itself, while protected variables and methods are accessible from within the class and its subclasses. This helps to further protect the data and methods of a class from unauthorized access."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Describe the key principles of encapsulation, including access control and data hiding."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encapsulation is a fundamental concept in object-oriented programming that involves bundling data (attributes) and methods (functions) that operate on that data into a single unit, known as a class. It also involves controlling the access to the internal state of an object, which is achieved through access control and data hiding. Let's explore the key principles of encapsulation, including these two aspects:\n",
    "\n",
    "## Access Control:\n",
    "\n",
    "Access control refers to the regulation of access to the attributes and methods of a class. In Python, access control is implemented through access modifiers:\n",
    "\n",
    "### Public Access (No Modifier):\n",
    "\n",
    "Members (attributes or methods) with no access modifier are public and can be accessed from anywhere.\n",
    "\n",
    "### Private Access (__):\n",
    "\n",
    "Members with names starting with double underscores (__) are private and can only be accessed within the class they are defined in.\n",
    "\n",
    "### Protected Access (_):\n",
    "\n",
    "Members with names starting with a single underscore (_) are protected and can be accessed within the class and its subclasses.\n",
    "\n",
    "Access control helps in preventing unauthorized access and manipulation of an object's internal state. It ensures that the object is used according to the intended design and interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Myclass:\n",
    "    def __init__(self):\n",
    "        self.public_member = 10  #public member\n",
    "        self._protected_member = 20 #protected member\n",
    "        self.__private_member = 30 #private member\n",
    "obj = Myclass()\n",
    "#only public member can be accessed by the object outside the class\n",
    "obj.public_member\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Hiding:\n",
    "\n",
    "Data hiding is a crucial aspect of encapsulation that involves restricting direct access to the internal state (attributes) of an object. It promotes the idea that the internal details of an object should be hidden from the outside world, and interactions with the object should occur through well-defined methods.\n",
    "\n",
    "By making attributes private or protected, and providing public methods to interact with them, encapsulation ensures that the internal state is accessed and modified in a controlled manner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    }
   ],
   "source": [
    "# for example\n",
    "class BankAccount:\n",
    "    def __init__(self, balance):\n",
    "        self.__balance = balance\n",
    "\n",
    "    def get_balance(self):\n",
    "        return self.__balance\n",
    "\n",
    "    def deposit(self, amount):\n",
    "        self.__balance += amount\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if amount <= self.__balance:\n",
    "            self.__balance -= amount\n",
    "        else:\n",
    "            print(\"Insufficient funds\")\n",
    "\n",
    "account = BankAccount(balance=1000)\n",
    "#Accessing the data through methods(abstraction)\n",
    "print(account.get_balance())  # Accessing balance through a method\n",
    "account.withdraw(500)         # Modifying balance through a method\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. How can you achieve encapsulation in Python classes? Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encapsulation in python can be primarily achieved in python by the help of data hiding(by using access modifiers) and data abstraction(by using methods to access the data.)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n",
      "500\n"
     ]
    }
   ],
   "source": [
    "#for example\n",
    "\n",
    "class BankAccount:\n",
    "    def __init__(self, balance):\n",
    "        self.__balance = balance #data hiding by making the variable private\n",
    "    \n",
    "    #Abstraction by using methods to access the data\n",
    "    def get_balance(self):\n",
    "        return self.__balance\n",
    "\n",
    "    def deposit(self, amount):\n",
    "        self.__balance += amount\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if amount <= self.__balance:\n",
    "            self.__balance -= amount\n",
    "        else:\n",
    "            print(\"Insufficient funds\")\n",
    "\n",
    "account = BankAccount(balance=1000)\n",
    "#Accessing the data through methods(abstraction)\n",
    "print(account.get_balance())  # Accessing balance through a method\n",
    "account.withdraw(500)         # Modifying balance through a method\n",
    "print(account.get_balance())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Discuss the difference between public, private, and protected access modifiers in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Public Access Modifier:\n",
    "\n",
    "Members (attributes or methods) with no access modifier are considered public by default.\n",
    "\n",
    "Public members are accessible from anywhere, both within the class and outside the class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "This is a public method.\n"
     ]
    }
   ],
   "source": [
    "# for example\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.public_variable = 42\n",
    "\n",
    "    def public_method(self):\n",
    "        print(\"This is a public method.\")\n",
    "\n",
    "obj = MyClass()\n",
    "print(obj.public_variable)  # Accessing a public variable\n",
    "obj.public_method()          # Accessing a public method\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Private Access Modifier (__):\n",
    "\n",
    "Members with names starting with double underscores (`__`) are considered private.\n",
    "\n",
    "Private members are only accessible within the class they are defined in.\n",
    "\n",
    "Access to private members from outside the class results in an AttributeError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'MyClass' object has no attribute '__private_variable'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_10332\\3984267603.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0mobj\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mMyClass\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;31m# This would result in an AttributeError since __private_variable is private\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__private_variable\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[1;31m# This would also result in an AttributeError since __private_method is private\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'MyClass' object has no attribute '__private_variable'"
     ]
    }
   ],
   "source": [
    "#for example\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.__private_variable = 10\n",
    "\n",
    "    def __private_method(self):\n",
    "        print(\"This is a private method.\")\n",
    "\n",
    "obj = MyClass()\n",
    "# This would result in an AttributeError since __private_variable is private\n",
    "print(obj.__private_variable)\n",
    "\n",
    "# This would also result in an AttributeError since __private_method is private\n",
    "obj.__private_method()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Protected Access Modifier (`_`):\n",
    "\n",
    "Members with names starting with a single underscore (`_`) are considered protected.\n",
    "\n",
    "Protected members are accessible within the class and its subclasses.\n",
    "\n",
    "There is no strict enforcement of protected access; it's more of a convention to indicate how the member should be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "Accessing protected variable: 20\n",
      "This is a protected method.\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self._protected_variable = 20\n",
    "\n",
    "    def _protected_method(self):\n",
    "        print(\"This is a protected method.\")\n",
    "\n",
    "class MySubClass(MyClass):\n",
    "    def access_protected(self):\n",
    "        print(f\"Accessing protected variable: {self._protected_variable}\")\n",
    "        self._protected_method()\n",
    "\n",
    "obj = MyClass()\n",
    "print(obj._protected_variable)  # Accessing a protected variable\n",
    "\n",
    "sub_obj = MySubClass()\n",
    "sub_obj.access_protected()  # Accessing protected variable and method in a subclass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Create a Python class called `Person` with a private attribute `__name`. Provide methods to get and set the name attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Rachit\n",
      "Name changed to Raman\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,name):\n",
    "        self.__name = name\n",
    "    def get_name(self):\n",
    "        print(\"Name:\",self.__name)\n",
    "    def set_name(self,new_name):\n",
    "        self.__name = new_name\n",
    "        print(\"Name changed to\",self.__name)\n",
    "obj = Person(\"Rachit\")\n",
    "obj.get_name()\n",
    "obj.set_name(\"Raman\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Explain the purpose of getter and setter methods in encapsulation. Provide examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getter and setter methods play a crucial role in encapsulation by providing controlled access to the attributes of a class. They help in maintaining the integrity of the class's internal state, enabling validation checks, and allowing for a level of abstraction between the internal representation and external access."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getter Methods:\n",
    "\n",
    "Purpose: Getter methods are used to retrieve the values of private attributes. They provide a way to access the internal state of an object in a controlled and read-only manner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.__name = name  # Private attribute\n",
    "    #getter method\n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "\n",
    "# Example usage\n",
    "person = Person(name=\"Rahul\")\n",
    "print(person.get_name())  # Accessing the private attribute through a getter method\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setter Methods:\n",
    "\n",
    "Purpose: Setter methods are used to modify the values of private attributes. They provide a controlled way to update the internal state of an object, allowing for validation checks or additional logic before modifying the attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rahul\n",
      "Raja\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.__name = name  # Private attribute\n",
    "    \n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "    #setter method\n",
    "    def set_name(self, new_name):\n",
    "        # Example: Applying a check to ensure the new name is not empty\n",
    "        if new_name:\n",
    "            self.__name = new_name\n",
    "\n",
    "# Example usage\n",
    "person = Person(name=\"Rahul\")\n",
    "print(person.get_name())\n",
    "person.set_name(\"Raja\")  # Modifying the private attribute through a setter method\n",
    "print(person.get_name())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. What is name mangling in Python, and how does it affect encapsulation?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Name mangling in Python is a mechanism that adds a prefix to names of attributes in a class to make them more \"private.\" It is a way to achieve a limited form of encapsulation by making it harder to accidentally access or override attributes that are intended to be internal to a class.\n",
    "\n",
    "In Python, name mangling is implemented by prefixing the name of an attribute with a double underscore (__). When name mangling is applied, the attribute's name is transformed to _classname__attribute. Here, classname is the name of the current class where the double underscore is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.__private_attribute = 42\n",
    "\n",
    "    def get_private_attribute(self):\n",
    "        return self.__private_attribute\n",
    "\n",
    "# Example usage\n",
    "obj = MyClass()\n",
    "print(obj.get_private_attribute())  # Accessing through a getter method\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'MyClass' object has no attribute '__private_attribute'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_10332\\2005293583.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# This would result in an AttributeError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__private_attribute\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'MyClass' object has no attribute '__private_attribute'"
     ]
    }
   ],
   "source": [
    "# This would result in an AttributeError\n",
    "print(obj.__private_attribute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "#but if we use name mangling we can access it\n",
    "print(obj._MyClass__private_attribute)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Impact on Encapsulation:\n",
    "### Limited Access Control:\n",
    "\n",
    "Name mangling is not a security feature; it's a convention that signals to developers that the attribute is intended to be private or for internal use only.\n",
    "\n",
    "## Avoiding Accidental Overriding:\n",
    "\n",
    "Name mangling helps in avoiding accidental overriding of attributes in subclasses. Since the mangled name includes the class name, it reduces the chances of naming conflicts with attributes in subclasses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Create a Python class called `BankAccount` with private attributes for the account balance (`__balance`) and account number (`__account_number`). Provide methods for depositing and withdrawing money."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amount deposited successfully!\n",
      "Amount withdrawn successfully!\n"
     ]
    }
   ],
   "source": [
    "class BankAccount:\n",
    "    def __init__(self,balance,ac_no):\n",
    "        self.__balance = balance\n",
    "        self.__account_number = ac_no\n",
    "    \n",
    "    def deposit(self,amt):\n",
    "        if amt >=0:\n",
    "            self.__balance += amt\n",
    "            print(\"Amount deposited successfully!\")\n",
    "        else:\n",
    "            print(\"Enter valid amount\")\n",
    "    \n",
    "    def withdraw(self,amt):\n",
    "        if amt <= self.__balance:\n",
    "            self.__balance -= amt\n",
    "            print(\"Amount withdrawn successfully!\")\n",
    "        else:\n",
    "            print(\"Insufficient balance!\")\n",
    "\n",
    "sbi = BankAccount(50000,\"SBI54789\")\n",
    "sbi.deposit(1000)\n",
    "sbi.withdraw(20000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Discuss the advantages of encapsulation in terms of code maintainability and security"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Encapsulation is one of the fundamental principles of object-oriented programming (OOP) and involves bundling the data (attributes) and methods that operate on the data into a single unit known as a class. The main advantages of encapsulation, particularly in terms of code maintainability and security, are as follows:\n",
    "\n",
    "## Code Maintainability:\n",
    "\n",
    "### Modularity:\n",
    "Encapsulation promotes modularity by grouping related attributes and methods together in a class. This makes it easier to understand and manage different components of a system separately.\n",
    "\n",
    "### Ease of Modification:\n",
    "Changes to the internal implementation of a class can be made without affecting the code that uses the class. The external code interacts with the class through its interface (public methods), and as long as that interface remains unchanged, the rest of the code remains unaffected.\n",
    "\n",
    "### Code Organization:\n",
    "Encapsulation helps organize code by providing a clear structure. It defines a boundary between the internal workings of a class and the external code that uses it. This separation simplifies the understanding and maintenance of the codebase.\n",
    "\n",
    "## Security:\n",
    "\n",
    "### Access Control:\n",
    "Encapsulation allows for the control of access to the internal state of an object. By marking attributes as private (using naming conventions like __ in Python), you restrict direct access from outside the class. Access is then provided through well-defined public methods, ensuring that data is accessed and modified in a controlled manner.\n",
    "\n",
    "### Prevention of Unauthorized Modifications:\n",
    "By encapsulating data and providing controlled access, encapsulation helps prevent unintended or unauthorized modifications to the internal state of an object. This is crucial for maintaining the integrity of the data.\n",
    "\n",
    "### Enhanced Data Integrity:\n",
    "Encapsulation helps in maintaining the integrity of the data by allowing only validated and controlled operations on it. This reduces the chances of data corruption or unintended changes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. How can you access private attributes in Python? Provide an example demonstrating the use of name mangling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the private attributes in python by the help of getter methods and name mangling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Private variable: 20\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "#for example:\n",
    "\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.__private_var = 20\n",
    "        \n",
    "    def getter(self):\n",
    "        return self.__private_var\n",
    "obj = MyClass()\n",
    "print(\"Private variable:\",obj.getter())  #accessing the private attribute by getter method\n",
    "print(obj._MyClass__private_var)   #accessing the private attribute through name mangling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. Create a Python class hierarchy for a school system, including classes for students, teachers, and courses, and implement encapsulation principles to protect sensitive information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ram is now teaching the Data science\n",
      "Rajeev successfully enrolled in DSA\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    \n",
    "    def __init__(self,name,age):\n",
    "        self.__name = name\n",
    "        self.__age = age\n",
    "        \n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "    \n",
    "    def get_age(self):\n",
    "        return self.__age\n",
    "\n",
    "class Student(Person):\n",
    "    \n",
    "    def __init__(self,name,age,student_id):\n",
    "        super().__init__(name,age)\n",
    "        self.__student_id = student_id\n",
    "        self.__courses_enrolled =[]\n",
    "    \n",
    "    def enroll_courses(self,course):\n",
    "        if course not in self.__courses_enrolled:\n",
    "            self.__courses_enrolled.append(course)\n",
    "            print(f\"{self.get_name()} successfully enrolled in {course}\")\n",
    "            \n",
    "    def get_enrolled_courses(self):\n",
    "        return self.__courses_enrolled\n",
    "\n",
    "class Teacher(Person):\n",
    "    def __init__(self, name, age, employee_id):\n",
    "        super().__init__(name, age)\n",
    "        self.__employee_id = employee_id\n",
    "        self.__courses_taught = []\n",
    "\n",
    "    def assign_course(self, course):\n",
    "        if course not in self.__courses_taught:\n",
    "            self.__courses_taught.append(course)\n",
    "            print(f\"{self.get_name()} is now teaching the {course}\")\n",
    "\n",
    "    def get_courses_taught(self):\n",
    "        return self.__courses_taught\n",
    "\n",
    "\n",
    "class Course:\n",
    "    def __init__(self, course_name, course_code):\n",
    "        self.__course_name = course_name\n",
    "        self.__course_code = course_code\n",
    "\n",
    "    def get_course_name(self):\n",
    "        return self.__course_name\n",
    "\n",
    "    def get_course_code(self):\n",
    "        return self.__course_code\n",
    "    \n",
    "computer_teacher = Teacher(name = \"Ram\", age = 27 , employee_id = \"E875\")\n",
    "maths_teacher = Teacher(name = \"Krish\", age = 55, employee_id = \"E973\")\n",
    "\n",
    "stud1 = Student(name = \"Rajeev\", age = 21, student_id = \"S786\")\n",
    "stud2 = Student(name = \"Sundar\", age = 19, student_id = \"S608\")\n",
    "\n",
    "course1 = Course(course_name = \"DSA\", course_code = \"826\")\n",
    "\n",
    "computer_teacher.assign_course(\"Data science\")\n",
    "stud1.enroll_courses(\"DSA\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12. Explain the concept of property decorators in Python and how they relate to encapsulation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Property decorators in Python are a special type of decorator that allows us to define properties on classes. Properties are special attributes that have getter, setter, and deleter methods. This allows us to control how the attribute is accessed and modified.\n",
    "Property decorators are related to encapsulation because they allow us to encapsulate data and the methods that work on that data within a single unit. This can help to protect the data from being accidentally modified and can also make the code more readable and maintainable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jhantu\n"
     ]
    }
   ],
   "source": [
    "#Here is an example of a property decorator:\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self._name = name\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self._name\n",
    "\n",
    "    @name.setter\n",
    "    def name(self, new_name):\n",
    "        if new_name is None:\n",
    "            raise ValueError(\"Name cannot be None\")\n",
    "        self._name = new_name\n",
    "\n",
    "    @name.deleter\n",
    "    def name(self):\n",
    "        del self._name\n",
    "\n",
    "per = Person(\"Jhantu\")\n",
    "print(per.name)\n",
    "per.name = \"Rajakannu\"\n",
    "del per.name\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the name attribute is a property. The @property decorator tells Python that the name attribute should be treated as a property. The @name.setter and @name.deleter decorators tell Python that the name attribute should have a setter and deleter method.\n",
    "The name property can be accessed and modified like any other attribute. However, the setter and deleter methods will be called before the attribute is actually set or deleted. This allows us to validate the data before it is set and to prevent the data from being accidentally deleted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13. What is data hiding, and why is it important in encapsulation? Provide examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data hiding is a concept in object-oriented programming (OOP) that refers to the practice of restricting direct access to certain attributes or methods of a class. It is a key aspect of encapsulation, one of the core principles of OOP. Encapsulation involves bundling data (attributes) and the methods that operate on the data into a single unit (a class) and controlling access to that unit. Data hiding is essential for maintaining the integrity of the class and preventing unauthorized or unintended access to its internal details.\n",
    "\n",
    "# Importance of Data Hiding in Encapsulation:\n",
    "\n",
    "## Encapsulation of Implementation Details:\n",
    "Data hiding allows us to hide the internal implementation details of a class. This means that the internal state of an object is not directly accessible from outside the class, preventing external code from depending on the internal structure of the class.\n",
    "\n",
    "## Controlled Access:\n",
    "By making certain attributes or methods private, we control how external code can interact with the class. This controlled access helps prevent unintended modifications or misuse of class internals.\n",
    "\n",
    "## Flexibility in Implementation:\n",
    "Data hiding provides flexibility in changing the internal implementation of a class without affecting the external code that uses the class. The class can evolve over time, and as long as the public interface (public methods) remains unchanged, the rest of the code remains unaffected.\n",
    "\n",
    "## Security:\n",
    "Hiding sensitive data or implementation details enhances the security of the application. It prevents unauthorized access to critical information and reduces the risk of data corruption or unintended modifications."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for example\n",
    "\n",
    "class BankAccount:\n",
    "    def __init__(self, account_number, initial_balance=0):\n",
    "        self.__account_number = account_number  # Private attribute\n",
    "        self.__balance = initial_balance         # Private attribute\n",
    "\n",
    "    def get_balance(self):\n",
    "        return self.__balance\n",
    "\n",
    "    def deposit(self, amount):\n",
    "        if amount > 0:\n",
    "            self.__balance += amount\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if 0 < amount <= self.__balance:\n",
    "            self.__balance -= amount\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 14. Create a Python class called `Employee` with private attributes for salary (`__salary`) and employee ID (`__employee_id`). Provide a method to calculate yearly bonuses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee ID: E001\n",
      "Salary: ₹50000\n",
      "Yearly Bonus (10%): ₹5000.0\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    def __init__(self, employee_id, salary):\n",
    "        self.__employee_id = employee_id\n",
    "        self.__salary = salary\n",
    "\n",
    "    def calculate_yearly_bonus(self, bonus_percentage):\n",
    "        \"\"\"\n",
    "        Calculate and return the yearly bonus based on the provided bonus percentage.\n",
    "\n",
    "        Args:\n",
    "            bonus_percentage (float): The bonus percentage to be applied.\n",
    "\n",
    "        Returns:\n",
    "            float: The calculated yearly bonus.\n",
    "        \"\"\"\n",
    "        if bonus_percentage < 0:\n",
    "            raise ValueError(\"Bonus percentage cannot be negative.\")\n",
    "\n",
    "        yearly_bonus = (bonus_percentage / 100) * self.__salary\n",
    "        return yearly_bonus\n",
    "\n",
    "    def get_employee_id(self):\n",
    "        return self.__employee_id\n",
    "\n",
    "    def get_salary(self):\n",
    "        return self.__salary\n",
    "\n",
    "\n",
    "# Example usage:\n",
    "employee1 = Employee(employee_id=\"E001\", salary=50000)\n",
    "\n",
    "# Calculate yearly bonus with a 10% bonus percentage\n",
    "bonus_percentage = 10\n",
    "yearly_bonus = employee1.calculate_yearly_bonus(bonus_percentage)\n",
    "\n",
    "# Display employee information and bonus\n",
    "print(f\"Employee ID: {employee1.get_employee_id()}\")\n",
    "print(f\"Salary: ₹{employee1.get_salary()}\")\n",
    "print(f\"Yearly Bonus ({bonus_percentage}%): ₹{yearly_bonus}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15. Discuss the use of accessors and mutators in encapsulation. How do they help maintain control over attribute access?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accessors and mutators are methods used in object-oriented programming to control access to the attributes of a class, ensuring encapsulation and maintaining control over attribute access.\n",
    "\n",
    "# Accessors (Getter Methods):\n",
    "\n",
    "## Purpose:\n",
    "Accessors are methods used to retrieve the values of private attributes.\n",
    "\n",
    "## Naming Convention: \n",
    "Typically named with the prefix \"get\" followed by the attribute name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Example\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.__attribute = 42\n",
    "\n",
    "    def get_attribute(self):\n",
    "        return self.__attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mutators (Setter Methods):\n",
    "\n",
    "## Purpose:\n",
    "Mutators are methods used to modify the values of private attributes.\n",
    "\n",
    "## Naming Convention:\n",
    "Typically named with the prefix \"set\" followed by the attribute name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#example\n",
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.__attribute = 42\n",
    "\n",
    "    def set_attribute(self, new_value):\n",
    "        # Additional validation or processing can be done here\n",
    "        self.__attribute = new_value\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They Help Maintain Control Over Attribute Access in the following ways:\n",
    "\n",
    "## Encapsulation:\n",
    "Accessors and mutators encapsulate the internal state of a class, ensuring that the details of the implementation are hidden from external code. This helps in preventing unintended interference with the class's internals.\n",
    "\n",
    "## Controlled Read and Write Access:\n",
    "Accessors provide controlled read access to private attributes, allowing external code to retrieve values without direct access to the attribute.\n",
    "Mutators provide controlled write access, enabling external code to modify the attribute, but with additional validation or processing as needed.\n",
    "\n",
    "## Flexibility in Implementation:\n",
    "By using accessors and mutators, you can change the internal implementation of a class without affecting the external code that uses the class. As long as the public interface (accessors and mutators) remains unchanged, the rest of the code remains unaffected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Celsius Temperature: 25\n",
      "Fahrenheit Temperature: 77.0\n",
      "Updated Celsius Temperature: 30\n",
      "Updated Fahrenheit Temperature: 86.0\n"
     ]
    }
   ],
   "source": [
    "#example\n",
    "\n",
    "class Temperature:\n",
    "    def __init__(self, celsius):\n",
    "        self.__celsius = celsius\n",
    "\n",
    "    def get_celsius(self):\n",
    "        return self.__celsius\n",
    "\n",
    "    def set_celsius(self, new_value):\n",
    "        if new_value < -273.15:\n",
    "            raise ValueError(\"Temperature cannot be below absolute zero.\")\n",
    "        self.__celsius = new_value\n",
    "\n",
    "    def get_fahrenheit(self):\n",
    "        return (self.__celsius * 9/5) + 32\n",
    "\n",
    "# Example usage:\n",
    "temperature_obj = Temperature(celsius=25)\n",
    "\n",
    "# Using accessors\n",
    "print(\"Celsius Temperature:\", temperature_obj.get_celsius())\n",
    "print(\"Fahrenheit Temperature:\", temperature_obj.get_fahrenheit())\n",
    "\n",
    "# Using mutator\n",
    "temperature_obj.set_celsius(30)\n",
    "print(\"Updated Celsius Temperature:\", temperature_obj.get_celsius())\n",
    "print(\"Updated Fahrenheit Temperature:\", temperature_obj.get_fahrenheit())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 16. What are the potential drawbacks or disadvantages of using encapsulation in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some of the potential drawbacks or disadvantages of using encapsulation in Python:\n",
    "\n",
    "## Increased code size:\n",
    "Encapsulation can increase the size of your code, as we need to provide accessors and mutators for each encapsulated variable.\n",
    "\n",
    "## Reduced flexibility:\n",
    "Encapsulation can make your code less flexible, as we need to go through the accessors and mutators to change the values of encapsulated variables.\n",
    "\n",
    "## Increased complexity:\n",
    "Encapsulation can add complexity to your code, as we need to think about how to encapsulate your data and how to provide access to it.\n",
    "\n",
    "## Reduced readability:\n",
    "Encapsulation can make our code less readable, as you need to understand how the accessors and mutators work in order to understand how the data is being used.\n",
    "\n",
    "## Increased testing overhead:\n",
    "Encapsulation can increase the overhead of testing our code, as we need to test the accessors and mutators as well as the encapsulated data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 17. Create a Python class for a library system that encapsulates book information, including titles, authors,and availability status."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book 1:\n",
      "Title: The fundamentals of algebra\n",
      "Author: Prabir Rudra\n",
      "Availability: Available\n",
      "\n",
      "The book 'The fundamentals of algebra' by Prabir Rudra has been borrowed.\n",
      "Sorry, the book 'The fundamentals of algebra' is currently not available.\n",
      "The book 'The fundamentals of algebra' by Prabir Rudra has been returned.\n",
      "The book 'The fundamentals of algebra' is already available. No need to return.\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author):\n",
    "        self.__title = title\n",
    "        self.__author = author\n",
    "        self.__is_available = True\n",
    "\n",
    "    def get_title(self):\n",
    "        return self.__title\n",
    "\n",
    "    def get_author(self):\n",
    "        return self.__author\n",
    "\n",
    "    def is_available(self):\n",
    "        return self.__is_available\n",
    "\n",
    "    def borrow_book(self):\n",
    "        if self.__is_available:\n",
    "            self.__is_available = False\n",
    "            print(f\"The book '{self.__title}' by {self.__author} has been borrowed.\")\n",
    "        else:\n",
    "            print(f\"Sorry, the book '{self.__title}' is currently not available.\")\n",
    "\n",
    "    def return_book(self):\n",
    "        if not self.__is_available:\n",
    "            self.__is_available = True\n",
    "            print(f\"The book '{self.__title}' by {self.__author} has been returned.\")\n",
    "        else:\n",
    "            print(f\"The book '{self.__title}' is already available. No need to return.\")\n",
    "\n",
    "# Example usage:\n",
    "book1 = Book(title=\"The fundamentals of algebra\", author=\"Prabir Rudra\")\n",
    "book2 = Book(title=\"Get started with C++\", author=\"Sumita Arora\")\n",
    "\n",
    "# Display book information\n",
    "print(\"Book 1:\")\n",
    "print(f\"Title: {book1.get_title()}\")\n",
    "print(f\"Author: {book1.get_author()}\")\n",
    "print(f\"Availability: {'Available' if book1.is_available() else 'Not Available'}\\n\")\n",
    "\n",
    "# Borrow a book\n",
    "book1.borrow_book()\n",
    "\n",
    "# Attempt to borrow an already borrowed book\n",
    "book1.borrow_book()\n",
    "\n",
    "# Return the borrowed book\n",
    "book1.return_book()\n",
    "\n",
    "# Attempt to return an already available book\n",
    "book1.return_book()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 18. Explain how encapsulation enhances code reusability and modularity in Python programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Encapsulation enhances code reusability and modularity in Python programs by promoting a well-defined and organized structure, which facilitates the creation of independent and reusable components. Here are ways in which encapsulation contributes to code reusability and modularity:\n",
    "\n",
    "## Abstraction:\n",
    "Encapsulation allows us to abstract away the implementation details of a class, exposing only a well-defined interface to the external world. This abstraction makes it easier for other parts of the code to use the class without needing to understand its internal complexities.\n",
    "\n",
    "## Modularity:\n",
    "Encapsulation facilitates the creation of modular code by grouping related attributes and methods into a single unit (class). Each class becomes a module with a clear purpose and functionality, making it easier to understand, maintain, and modify independently.\n",
    "\n",
    "## Reduced Interdependence:\n",
    "By encapsulating the internal details within a class, the rest of the code interacts with the class through its public interface (methods). This reduces interdependence between different parts of the code, allowing changes to one module without affecting others, as long as the interface remains unchanged.\n",
    "\n",
    "## Code Reusability:\n",
    "Encapsulation promotes code reusability by creating classes that can be reused in different parts of the code or even in different projects. Once a class is designed and implemented, it can be easily reused without the need to understand or modify its internal workings.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 19. Describe the concept of information hiding in encapsulation. Why is it essential in software development?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Information hiding is a fundamental concept in encapsulation that involves concealing the internal details or implementation of a class from the outside world, exposing only what is necessary for the proper use of the class. The goal is to restrict access to certain aspects of the class, such as its attributes or implementation details, and present a well-defined and controlled interface to the external code.\n",
    "\n",
    "Key principles of information hiding in encapsulation include:\n",
    "\n",
    "## Private Attributes and Methods:\n",
    "Using access modifiers to designate certain attributes or methods as private, meaning they can only be accessed or modified from within the class itself.\n",
    "\n",
    "## Abstraction:\n",
    "Providing an abstract, high-level view of the class's functionality through a well-defined interface while hiding the lower-level details.\n",
    "\n",
    "## Accessors and Mutators:\n",
    "Using accessor (getter) and mutator (setter) methods to control access to attributes, allowing read-only or controlled write access.\n",
    "\n",
    "Information Hiding Is Essential in Software Development because:\n",
    "\n",
    "## Modularity:\n",
    "Information hiding contributes to the creation of modular code by encapsulating related functionalities within a class. Each module (class) becomes a self-contained unit with its own well-defined interface.\n",
    "\n",
    "## Encapsulation of Complexity:\n",
    "By hiding the internal complexity of a class, developers can use the class without needing to understand its intricate details. This abstraction simplifies the usage and promotes ease of comprehension.\n",
    "\n",
    "## Security:\n",
    "Hiding sensitive information or implementation details enhances the security of the application. By exposing only what is necessary, the risk of unintended access or manipulation of critical information is reduced.\n",
    "\n",
    "## Team Collaboration:\n",
    "Information hiding facilitates team collaboration by allowing different team members to work on separate components without interfering with each other. Each team member can focus on their assigned module without needing an in-depth understanding of the entire system.\n",
    "\n",
    "In conclusion, information hiding is essential in software development because it promotes modularity, encapsulates complexity, eases maintenance, enhances security, reduces the impact of changes, ensures code stability, improves code readability, and facilitates team collaboration. These benefits contribute to the development of robust, maintainable, and secure software systems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 20. Create a Python class called `Customer` with private attributes for customer details like name, address, and contact information. Implement encapsulation to ensure data integrity and security."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Customer Name: Rajeev\n",
      "Customer Address: Poddar lane\n",
      "Customer Contact Info: abc@gmail.com\n",
      "Contact information updated successfully.\n",
      "Updated Customer Contact Info: new.email@example.com\n"
     ]
    }
   ],
   "source": [
    "class Customer:\n",
    "    def __init__(self, name, address, contact_info):\n",
    "        self.__name = name\n",
    "        self.__address = address\n",
    "        self.__contact_info = contact_info\n",
    "\n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "\n",
    "    def get_address(self):\n",
    "        return self.__address\n",
    "\n",
    "    def get_contact_info(self):\n",
    "        return self.__contact_info\n",
    "\n",
    "    def update_contact_info(self, new_contact_info):\n",
    "        self.__contact_info = new_contact_info\n",
    "        print(\"Contact information updated successfully.\")\n",
    "\n",
    "# Example usage:\n",
    "customer1 = Customer(name=\"Rajeev\", address=\"Poddar lane\", contact_info=\"abc@gmail.com\")\n",
    "\n",
    "# Accessing customer information using accessor methods\n",
    "print(\"Customer Name:\", customer1.get_name())\n",
    "print(\"Customer Address:\", customer1.get_address())\n",
    "print(\"Customer Contact Info:\", customer1.get_contact_info())\n",
    "\n",
    "\n",
    "# Updating contact information using the mutator method\n",
    "customer1.update_contact_info(new_contact_info=\"new.email@example.com\")\n",
    "\n",
    "# Display updated contact information\n",
    "print(\"Updated Customer Contact Info:\", customer1.get_contact_info())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Polymorphism:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. What is polymorphism in Python? Explain how it is related to object-oriented programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Polymorphism is a fundamental concept in object-oriented programming that allows for the same function to be used with different types of objects. This is achieved through the use of inheritance and method overriding.\n",
    "In Python, polymorphism is implemented through duck typing, which means that the type of an object is determined by its methods, rather than its class. This allows for greater flexibility and code reuse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Driving...\n",
      "Pedaling...\n",
      "Flying...\n"
     ]
    }
   ],
   "source": [
    "#For example\n",
    "class Vehicle:\n",
    "    def move(self):\n",
    "        pass\n",
    "\n",
    "class Car(Vehicle):\n",
    "    def move(self):\n",
    "        print(\"Driving...\")\n",
    "\n",
    "class Bicycle(Vehicle):\n",
    "    def move(self):\n",
    "        print(\"Pedaling...\")\n",
    "\n",
    "class Airplane(Vehicle):\n",
    "    def move(self):\n",
    "        print(\"Flying...\")\n",
    "\n",
    "car = Car()\n",
    "bicycle = Bicycle()\n",
    "airplane = Airplane()\n",
    "\n",
    "car.move()  \n",
    "bicycle.move()  \n",
    "airplane.move()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# 2. Describe the difference between compile-time polymorphism and runtime polymorphism in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compile-time polymorphism:\n",
    "Also known as method overloading, it involves defining multiple methods with the same name in the same class but with different parameter types or a different number of parameters. The correct method is selected at compile time based on the method signature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#For example \n",
    "\n",
    "class MathOperations:\n",
    "    def add(self, a, b):\n",
    "        return a + b\n",
    "\n",
    "    def add(self, a, b, c):\n",
    "        return a + b + c\n",
    "\n",
    "math_obj = MathOperations()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "add() missing 1 required positional argument: 'c'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_9648\\2209214015.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mresult1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmath_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# This will not work due to compile-time error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: add() missing 1 required positional argument: 'c'"
     ]
    }
   ],
   "source": [
    "result1 = math_obj.add(2, 3)  # This will not work due to compile-time error\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "result2 = math_obj.add(2, 3, 4)  # This will work\n",
    "print(result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Runtime polymorphism:\n",
    "Also known as method overriding, it involves defining a method in the base class and then redefining it in the derived class. The correct method is selected at runtime based on the type of the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "#For example\n",
    "class Animal:\n",
    "    def sound(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def sound(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "class Cat(Animal):\n",
    "    def sound(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "def animal_sound(animal):\n",
    "    return animal.sound()\n",
    "\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "print(animal_sound(dog))  \n",
    "print(animal_sound(cat)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Create a Python class hierarchy for shapes (e.g., circle, square, triangle) and demonstrate polymorphism through a common method, such as `calculate_area()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of Circle: 50.24\n",
      "Area of Square: 25\n",
      "Area of Triangle: 10.5\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    \n",
    "    def calculate_area(self):\n",
    "        pass\n",
    "    \n",
    "class Circle(Shape):\n",
    "    \n",
    "    def __init__(self,radius):\n",
    "        self.radius = radius\n",
    "        \n",
    "    def calculate_area(self):\n",
    "        return 3.14*(self.radius**2)\n",
    "    \n",
    "class Square(Shape):\n",
    "    \n",
    "    def __init__(self,side):\n",
    "        self.side = side\n",
    "        \n",
    "    def calculate_area(self):\n",
    "        return self.side*self.side\n",
    "    \n",
    "class Triangle(Shape):\n",
    "    \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",
    "# Example of polymorphism\n",
    "shapes = [Circle(4), Square(5), Triangle(3, 7)]\n",
    "\n",
    "for shape in shapes:\n",
    "    print(f\"Area of {shape.__class__.__name__}: {shape.calculate_area()}\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Explain the concept of method overriding in polymorphism. Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Method overriding` is a concept in object-oriented programming (OOP) that allows a subclass to provide a specific implementation of a method that is already defined in its superclass. When a method is overridden, it means that the subclass provides its own version of the method, effectively replacing or extending the behavior of the method in the superclass.\n",
    "\n",
    "In Python, method overriding is a form of runtime polymorphism, where the specific method that gets executed is determined dynamically during runtime based on the actual type of the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "#For example\n",
    "#For example\n",
    "class Animal:\n",
    "    def sound(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def sound(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "class Cat(Animal):\n",
    "    def sound(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "def animal_sound(animal):\n",
    "    return animal.sound()\n",
    "\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "print(animal_sound(dog))  \n",
    "print(animal_sound(cat)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. How is polymorphism different from method overloading in Python? Provide examples for both."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, polymorphism and method overloading are related concepts but are distinct from each other.\n",
    "`Polymorphism` allows objects of different types to be treated as objects of a common type. In Python, polymorphism is achieved through duck typing, where the type or class of an object is determined by its behavior, rather than its explicit type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "#For example\n",
    "class Dog:\n",
    "    def sound(self):\n",
    "        return \"Woof!\"\n",
    "\n",
    "class Cat:\n",
    "    def sound(self):\n",
    "        return \"Meow!\"\n",
    "\n",
    "def make_sound(animal):\n",
    "    return animal.sound()\n",
    "\n",
    "# Both Dog and Cat can be treated as types of animals\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "print(make_sound(dog)) \n",
    "print(make_sound(cat))  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Method overloading` allows a class to define multiple methods with the same name but with a different number or type of parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#For example\n",
    "class MathOperations:\n",
    "    def add(self, a, b):\n",
    "        return a + b\n",
    "\n",
    "    def add(self, a, b, c):\n",
    "        return a + b + c\n",
    "\n",
    "math_obj = MathOperations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "add() missing 1 required positional argument: 'c'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_16864\\1342942885.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mresult1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmath_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# This will not work due to compile-time error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: add() missing 1 required positional argument: 'c'"
     ]
    }
   ],
   "source": [
    "result1 = math_obj.add(2, 3)  # This will not work due to compile-time error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "result2 = math_obj.add(2, 3, 4)  # This will work\n",
    "print(result2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. 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 on objects of different subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n",
      "Chirp!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        pass\n",
    "    \n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Meow!\")\n",
    "        \n",
    "class Bird(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Chirp!\")\n",
    "        \n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "bird = Bird()\n",
    "\n",
    "dog.speak()\n",
    "cat.speak()\n",
    "bird.speak()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Discuss the use of abstract methods and classes in achieving polymorphism in Python. Provide an example using the `abc` module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, abstract methods and classes provide a way to enforce a certain structure in subclasses, ensuring that they implement specific methods. This is particularly useful for achieving polymorphism, as it allows us to define a common interface that multiple classes must adhere to.\n",
    "\n",
    "The abc module (Abstract Base Classes) in Python provides the tools to create abstract classes and abstract methods. An abstract class cannot be instantiated, and any subclass must provide concrete implementations for all abstract methods defined in the abstract base class.\n",
    "\n",
    "Here's an example demonstrating the use of the abc module to create an abstract base class and achieve polymorphism:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n",
      "Tweet!\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract base class\n",
    "class Animal(ABC):\n",
    "    @abstractmethod\n",
    "    def speak(self):\n",
    "        pass  # Abstract method that must be implemented by subclasses\n",
    "\n",
    "# Concrete subclasses\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",
    "class Bird(Animal):\n",
    "    def speak(self):\n",
    "        return \"Tweet!\"\n",
    "\n",
    "# Demonstrate polymorphism\n",
    "def animal_says(animal):\n",
    "    return animal.speak()\n",
    "\n",
    "# Attempting to instantiate the abstract class will raise a TypeError\n",
    "#animal = Animal()  # Uncommenting this line will result in an error\n",
    "\n",
    "# Create instances of each concrete subclass\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "bird = Bird()\n",
    "\n",
    "# Call the speak() method on objects of different subclasses\n",
    "print(animal_says(dog))  # Outputs: Woof!\n",
    "print(animal_says(cat))  # Outputs: Meow!\n",
    "print(animal_says(bird)) # Outputs: Tweet!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example:\n",
    "\n",
    "The Animal class is an abstract base class (indicated by inheriting from ABC and using the @abstractmethod decorator for the speak method).\n",
    "\n",
    "The Dog, Cat, and Bird classes inherit from the Animal class and provide concrete implementations for the speak method.\n",
    "\n",
    "The animal_says function takes an Animal object as an argument and calls its speak method, demonstrating polymorphism.\n",
    "\n",
    "Attempting to create an instance of the abstract class directly (Animal()) will result in a TypeError. This ensures that subclasses must provide concrete implementations for all abstract methods, enforcing the desired behavior."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. 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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vehicle is starting!\n",
      "Car is starting!\n",
      "Bicycle is starting!\n",
      "Boat is starting!\n"
     ]
    }
   ],
   "source": [
    "class Vehicle:\n",
    "    def start(self):\n",
    "        print(\"Vehicle is starting!\")\n",
    "        \n",
    "class Car(Vehicle):\n",
    "    def start(self):\n",
    "        print(\"Car is starting!\")\n",
    "    \n",
    "class Bicycle(Vehicle):\n",
    "    def start(self):\n",
    "        print(\"Bicycle is starting!\")\n",
    "        \n",
    "class Boat(Vehicle):\n",
    "    def start(self):\n",
    "        print(\"Boat is starting!\")\n",
    "        \n",
    "vehicle = Vehicle()\n",
    "car = Car()\n",
    "bicycle = Bicycle()\n",
    "boat = Boat()\n",
    "\n",
    "vehicle.start()\n",
    "car.start()\n",
    "bicycle.start()\n",
    "boat.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Explain the significance of the `isinstance()` and `issubclass()` functions in Python polymorphism."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `isinstance()` and `issubclass()` functions in Python play significant roles in the context of polymorphism by providing mechanisms to check the type and inheritance relationships between objects and classes. These functions are essential for writing flexible and polymorphic code. Here's an explanation of their significance:\n",
    "\n",
    "1. **`isinstance()` Function:**\n",
    "   - **Purpose:** This function is used to check if an object belongs to a particular class or a tuple of classes.\n",
    "   - **Significance in Polymorphism:**\n",
    "     - Enables dynamic type checking, allowing code to handle objects of different types in a flexible way.\n",
    "     - Facilitates polymorphic behavior by allowing code to adapt based on the actual type of an object at runtime.\n",
    "   - **Example:**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    pass\n",
    "\n",
    "class Cat(Animal):\n",
    "    pass\n",
    "\n",
    "# Creating instances of classes\n",
    "dog_instance = Dog()\n",
    "cat_instance = Cat()\n",
    "\n",
    "# Using isinstance() for polymorphic behavior\n",
    "def animal_sound(animal):\n",
    "    if isinstance(animal, Dog):\n",
    "        return \"Woof!\"\n",
    "    elif isinstance(animal, Cat):\n",
    "        return \"Meow!\"\n",
    "\n",
    "print(animal_sound(dog_instance))  \n",
    "print(animal_sound(cat_instance))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "In this example, `isinstance()` is used to check the type of the object passed to the `animal_sound` function, allowing for different behavior based on the actual type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **`issubclass()` Function:**\n",
    "   - **Purpose:** This function checks if a class is a subclass of another class or a tuple of classes.\n",
    "   - **Significance in Polymorphism:**\n",
    "     - Useful for checking class hierarchies and ensuring that a class inherits from a specific base class.\n",
    "     - Helps in designing polymorphic interfaces by verifying if a class adheres to a certain inheritance structure.\n",
    "   - **Example:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating area of a circle\n",
      "Calculating area of a square\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    pass\n",
    "\n",
    "class Circle(Shape):\n",
    "    pass\n",
    "\n",
    "class Square(Shape):\n",
    "    pass\n",
    "\n",
    "# Using issubclass() for polymorphic behavior\n",
    "def area_of_shape(shape_class):\n",
    "\n",
    "    if issubclass(shape_class, Circle):\n",
    "        return \"Calculating area of a circle\"\n",
    "    elif issubclass(shape_class, Square):\n",
    "        return \"Calculating area of a square\"\n",
    "\n",
    "print(area_of_shape(Circle))  \n",
    "print(area_of_shape(Square)) \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. What is the role of the `@abstractmethod` decorator in achieving polymorphism in Python? Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `@abstractmethod` decorator in Python is part of the `abc` module (Abstract Base Classes) and is used to define abstract methods in abstract base classes. Abstract methods are methods that have no implementation in the abstract class itself but must be implemented by concrete subclasses. The `@abstractmethod` decorator enforces that any concrete subclass must provide a concrete implementation for the abstract method, ensuring a consistent interface.\n",
    "\n",
    "The role of `@abstractmethod` in achieving polymorphism is to define a common interface for a group of related classes, allowing them to be treated interchangeably through a shared method signature. This helps in achieving polymorphic behavior, as different objects can respond to the same method calls in a consistent way.\n",
    "\n",
    "Here's an example illustrating the use of `@abstractmethod` for achieving polymorphism:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the shape: 78.5\n",
      "Area of the shape: 16\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract base class\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass  # Abstract method to be implemented by subclasses\n",
    "\n",
    "# Concrete subclasses\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return 3.14 * self.radius * self.radius\n",
    "\n",
    "class Square(Shape):\n",
    "    def __init__(self, side):\n",
    "        self.side = side\n",
    "\n",
    "    def area(self):\n",
    "        return self.side * self.side\n",
    "\n",
    "# Function demonstrating polymorphism\n",
    "def print_area(shape):\n",
    "    print(f\"Area of the shape: {shape.area()}\")\n",
    "\n",
    "# Create instances of concrete subclasses\n",
    "circle = Circle(radius=5)\n",
    "square = Square(side=4)\n",
    "\n",
    "# Call the common interface method on objects of different subclasses\n",
    "print_area(circle) \n",
    "print_area(square) \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By using the `@abstractmethod` decorator, we ensure that any class inheriting from `Shape` must provide a concrete implementation for the `area` method. This common interface allows us to treat different shapes interchangeably, achieving polymorphic behavior."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. Create a Python class called `Shape` with a polymorphic method `area()` that calculates the area of different shapes (e.g., circle, rectangle, triangle).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the shape: 78.5\n",
      "Area of the shape: 50\n",
      "Area of the shape: 25.0\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    def area(self):\n",
    "        pass\n",
    "    \n",
    "class Circle(Shape):\n",
    "    \n",
    "    def __init__(self,radius):\n",
    "        self.radius = radius\n",
    "        \n",
    "    def area(self):\n",
    "        return 3.14 * self.radius * self.radius\n",
    "    \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",
    "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):\n",
    "    print(f\"Area of the shape: {shape.area()}\")\n",
    "    \n",
    "circle = Circle(radius = 5)\n",
    "rectangle = Rectangle(length=10,width=5)\n",
    "triangle = Triangle(base=5,height=10)\n",
    "\n",
    "print_area(circle)\n",
    "print_area(rectangle)\n",
    "print_area(triangle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12. Discuss the benefits of polymorphism in terms of code reusability and flexibility in Python programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Polymorphism in Python brings several benefits, particularly in terms of code reusability and flexibility. Here are some key advantages:\n",
    "\n",
    "1. **Code Reusability:**\n",
    "   - **Interface Consistency:** Polymorphism allows us to define a common interface (methods or behaviors) in a base class, and this interface can be reused across multiple subclasses. This promotes consistency and reduces the need to rewrite code for similar functionalities in different parts of your program.\n",
    "   - **Generic Code:** With polymorphism, you can write generic functions or methods that work with objects of a common base type. These functions can be reused with different subclasses, as long as they adhere to the common interface.\n",
    "\n",
    "2. **Flexibility:**\n",
    "   - **Adaptability to Change:** Polymorphism makes our code more adaptable to changes in requirements. Adding a new subclass that follows the same interface allows you to seamlessly integrate new functionality without modifying existing code that relies on the common interface.\n",
    "   - **Plug-and-Play Components:** Polymorphic behavior allows us to use different components interchangeably. For example, if a function expects an object of a certain type, any subclass of that type can be used without modifying the function. This makes it easy to swap components or extend functionality without affecting the existing code.\n",
    "\n",
    "\n",
    "In summary, polymorphism in Python promotes code reusability by providing a mechanism for defining and enforcing a common interface across different classes. This not only enhances flexibility in adapting to changes but also reduces code duplication and improves the overall readability of the codebase. It is a powerful feature that contributes to the maintainability and extensibility of Python programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13. Explain the use of the `super()` function in Python polymorphism. How does it help call methods of parent classes?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `super()` function in Python is used to call a method from the parent class in a derived (subclass) class. It allows you to invoke a method in a superclass and access its functionality, contributing to a concept known as method resolution order (MRO). `super()` is commonly used within the context of polymorphism to extend or override methods in a way that maintains the functionality of the parent class.\n",
    "\n",
    "### Use in Polymorphism:\n",
    "\n",
    "The `super()` function becomes particularly useful in polymorphic scenarios where you have a common method name in both the parent and child classes. By using `super()`, you ensure that the method from the parent class is executed first, and then you can add or modify functionality in the child class.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generic animal sound\n",
      "Woof!\n",
      "Generic animal sound\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def make_sound(self):\n",
    "        print(\"Generic animal sound\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def make_sound(self):\n",
    "        super().make_sound()  # Call the make_sound method of the parent class\n",
    "        print(\"Woof!\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def make_sound(self):\n",
    "        super().make_sound()  # Call the make_sound method of the parent class\n",
    "        print(\"Meow!\")\n",
    "\n",
    "# Polymorphic function that works with any Animal object\n",
    "def animal_says(animal):\n",
    "    animal.make_sound()\n",
    "\n",
    "# Create instances of the Dog and Cat classes\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "# Demonstrate polymorphism using the common interface\n",
    "animal_says(dog)\n",
    "animal_says(cat)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the `Animal` class defines a `make_sound` method. Both the `Dog` and `Cat` classes inherit from `Animal` and override the `make_sound` method. By using `super().make_sound()`, each subclass calls the `make_sound` method of the `Animal` class before adding its own sound.\n",
    "\n",
    "This use of `super()` ensures that the code remains flexible and adheres to the principles of polymorphism, allowing for easy extension and modification of behavior in derived classes while preserving the functionality of the parent class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 14. Create a Python class hierarchy for a banking system with various account types (e.g., savings, checking, credit card) and demonstrate polymorphism by implementing a common `withdraw()` method.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Performing withdrawal for Account SA001:\n",
      "Withdrew ₹200. Remaining balance: ₹800\n",
      "Account SA001 balance: ₹800\n",
      "\n",
      "Performing withdrawal for Account CA001:\n",
      "Withdrew ₹700. Remaining balance: ₹4300\n",
      "Account CA001 balance: ₹4300\n",
      "\n",
      "Performing withdrawal for Account CC001:\n",
      "Withdrew ₹500. Remaining balance: ₹1500\n",
      "Account CC001 balance: ₹1500\n"
     ]
    }
   ],
   "source": [
    "class BankAccount:\n",
    "    def __init__(self, account_number, balance=0):\n",
    "        self.account_number = account_number\n",
    "        self.balance = balance\n",
    "\n",
    "    def deposit(self, amount):\n",
    "        self.balance += amount\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if amount <= self.balance:\n",
    "            self.balance -= amount\n",
    "            print(f\"Withdrew ₹{amount}. Remaining balance: ₹{self.balance}\")\n",
    "        else:\n",
    "            print(\"Insufficient funds. Withdrawal canceled.\")\n",
    "\n",
    "    def display_balance(self):\n",
    "        print(f\"Account {self.account_number} balance: ₹{self.balance}\")\n",
    "\n",
    "\n",
    "class SavingsAccount(BankAccount):\n",
    "    def __init__(self, account_number, balance=0, interest_rate=0.02):\n",
    "        super().__init__(account_number, balance)\n",
    "        self.interest_rate = interest_rate\n",
    "\n",
    "    def apply_interest(self):\n",
    "        interest_amount = self.balance * self.interest_rate\n",
    "        self.deposit(interest_amount)\n",
    "        print(f\"Interest applied. New balance: ₹{self.balance}\")\n",
    "\n",
    "\n",
    "class CheckingAccount(BankAccount):\n",
    "    def __init__(self, account_number, balance=0, overdraft_limit=100):\n",
    "        super().__init__(account_number, balance)\n",
    "        self.overdraft_limit = overdraft_limit\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if amount <= (self.balance + self.overdraft_limit):\n",
    "            self.balance -= amount\n",
    "            print(f\"Withdrew ₹{amount}. Remaining balance: ₹{self.balance}\")\n",
    "        else:\n",
    "            print(\"Insufficient funds. Withdrawal canceled.\")\n",
    "\n",
    "\n",
    "class CreditCardAccount(BankAccount):\n",
    "    def __init__(self, account_number, balance=0, credit_limit=1000):\n",
    "        super().__init__(account_number, balance)\n",
    "        self.credit_limit = credit_limit\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if amount <= (self.balance + self.credit_limit):\n",
    "            self.balance -= amount\n",
    "            print(f\"Withdrew ₹{amount}. Remaining balance: ₹{self.balance}\")\n",
    "        else:\n",
    "            print(\"Exceeded credit limit. Withdrawal canceled.\")\n",
    "\n",
    "\n",
    "# Demonstrate polymorphism\n",
    "def perform_withdrawal(account, amount):\n",
    "    print(f\"\\nPerforming withdrawal for Account {account.account_number}:\")\n",
    "    account.withdraw(amount)\n",
    "    account.display_balance()\n",
    "\n",
    "\n",
    "# Create instances of different account types\n",
    "savings_account = SavingsAccount(account_number=\"SA001\", balance=1000)\n",
    "checking_account = CheckingAccount(account_number=\"CA001\", balance=5000, overdraft_limit=200)\n",
    "credit_card_account = CreditCardAccount(account_number=\"CC001\", balance=2000, credit_limit=1000)\n",
    "\n",
    "# Demonstrate polymorphism by calling the common withdraw() method\n",
    "perform_withdrawal(savings_account, amount=200)\n",
    "perform_withdrawal(checking_account, amount=700)\n",
    "perform_withdrawal(credit_card_account, amount=500)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15. Describe the concept of operator overloading in Python and how it relates to polymorphism. Provide examples using operators like `+` and `*`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operator Overloading means giving extended meaning beyond their predefined operational meaning. For example operator + is used to add two integers as well as join two strings and merge two lists. It is achievable because ‘+’ operator is overloaded by int class and str class.\n",
    "\n",
    "Polymorphism allows different classes to be treated as instances of the same class, which is particularly useful when working with different types of objects in a unified manner.\n",
    "\n",
    "In the context of operator overloading, polymorphism means that different classes can define their own behavior for the same operator, making the code more flexible and expressive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "pwSkills\n",
      "12\n",
      "pwpwpwpw\n"
     ]
    }
   ],
   "source": [
    "# + operator for different purposes.\n",
    "\n",
    "print(1 + 2)\n",
    "\n",
    "# concatenate two strings\n",
    "print(\"pw\"+\"Skills\") \n",
    "\n",
    "# * operator for different purposes\n",
    "# Product two numbers\n",
    "print(3 * 4)\n",
    "\n",
    "# Repeat the String\n",
    "print(\"pw\"*4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 16. What is dynamic polymorphism, and how is it achieved in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dynamic polymorphism is a feature of object-oriented programming that allows objects of different types to be treated as if they were the same type. This is achieved through the use of inheritance and method overriding.\n",
    "\n",
    "In Python, dynamic polymorphism is achieved through the use of duck typing. Duck typing is a form of dynamic typing in which the type of an object is determined by the methods that it defines, rather than by its class. This means that an object can be used as if it were a different type, as long as it defines the required methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Meow!\")\n",
    "\n",
    "animals = [Dog(), Cat()]\n",
    "\n",
    "for animal in animals:\n",
    "    animal.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 17. 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": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tony stark: ₹110000\n",
      "Steve Evans: ₹80000\n",
      "Peter Parker: ₹60000\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    def __init__(self, name, salary):\n",
    "        self.name = name\n",
    "        self.salary = salary\n",
    "\n",
    "    def calculate_salary(self):\n",
    "        return self.salary\n",
    "\n",
    "class Manager(Employee):\n",
    "    def __init__(self, name, salary, bonus):\n",
    "        super().__init__(name, salary)\n",
    "        self.bonus = bonus\n",
    "\n",
    "    def calculate_salary(self):\n",
    "        return self.salary + self.bonus\n",
    "\n",
    "class Developer(Employee):\n",
    "    def __init__(self, name, salary, experience):\n",
    "        super().__init__(name, salary)\n",
    "        self.experience = experience\n",
    "\n",
    "    def calculate_salary(self):\n",
    "        return self.salary + (self.experience * 1000)\n",
    "\n",
    "class Designer(Employee):\n",
    "    def __init__(self, name, salary, awards):\n",
    "        super().__init__(name, salary)\n",
    "        self.awards = awards\n",
    "\n",
    "    def calculate_salary(self):\n",
    "        return self.salary + (self.awards * 5000)\n",
    "\n",
    "employees = [\n",
    "    Manager(\"Tony stark\", 100000, 10000),\n",
    "    Developer(\"Steve Evans\", 75000, 5),\n",
    "    Designer(\"Peter Parker\", 50000, 2)\n",
    "]\n",
    "\n",
    "for employee in employees:\n",
    "    print(f\"{employee.name}: ₹{employee.calculate_salary()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 18. Discuss the concept of function pointers and how they can be used to achieve polymorphism in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, the concept of function pointers is closely related to the use of first-class functions and higher-order functions. While Python does not have explicit function pointers like some other languages, the ability to pass functions as arguments and return them from functions allows for a form of polymorphism and flexibility in programming.\n",
    "\n",
    "### First-Class Functions in Python:\n",
    "\n",
    "In Python, functions are first-class citizens, which means they can be:\n",
    "\n",
    "1. Assigned to variables.\n",
    "2. Passed as arguments to other functions.\n",
    "3. Returned as values from other functions.\n",
    "\n",
    "### Higher-Order Functions:\n",
    "\n",
    "A higher-order function is a function that takes one or more functions as arguments or returns a function as a result. These functions facilitate the use of function pointers and contribute to achieving polymorphism.\n",
    "\n",
    "### Achieving Polymorphism with Function Pointers:\n",
    "\n",
    "In Python, you can use function pointers, or more precisely, function references, to achieve polymorphism by passing functions as arguments to other functions. This allows you to write generic functions that can work with different behaviors based on the functions provided.\n",
    "\n",
    "Here's a simple example to illustrate the concept:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition: 8\n",
      "Subtraction: 6\n",
      "Multiplication: 24\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "def subtract(x, y):\n",
    "    return x - y\n",
    "\n",
    "def multiply(x, y):\n",
    "    return x * y\n",
    "\n",
    "def calculate(operation, x, y):\n",
    "    return operation(x, y)\n",
    "\n",
    "# Using function pointers to achieve polymorphism\n",
    "result_add = calculate(add, 5, 3)\n",
    "result_subtract = calculate(subtract, 8, 2)\n",
    "result_multiply = calculate(multiply, 4, 6)\n",
    "\n",
    "print(\"Addition:\", result_add)       \n",
    "print(\"Subtraction:\", result_subtract) \n",
    "print(\"Multiplication:\", result_multiply) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example:\n",
    "\n",
    "- `add`, `subtract`, and `multiply` are functions that perform different operations.\n",
    "- The `calculate` function takes an operation function as an argument and applies it to the provided values `x` and `y`.\n",
    "\n",
    "This demonstrates a form of polymorphism, where the behavior of the `calculate` function is determined by the function passed as an argument.\n",
    "\n",
    "### Lambda Functions for Conciseness:\n",
    "\n",
    "You can also use lambda functions for concise representation when passing short and simple functions:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Power: 8\n"
     ]
    }
   ],
   "source": [
    "\n",
    "result_power = calculate(lambda x, y: x ** y, 2, 3)\n",
    "print(\"Power:\", result_power) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, a lambda function is used as a function pointer to calculate the power.\n",
    "\n",
    "In summary, while Python doesn't have explicit function pointers, the ability to use first-class functions and higher-order functions allows for a flexible and polymorphic approach by passing functions as arguments to achieve different behaviors in functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 19. Explain the role of interfaces and abstract classes in polymorphism, drawing comparisons between them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, both interfaces and abstract classes play a role in achieving polymorphism by defining common interfaces that multiple classes can implement. However, Python does not have explicit support for interfaces in the same way as some other programming languages. Instead, it uses abstract classes and abstract methods to achieve similar goals.\n",
    "\n",
    "### Abstract Classes:\n",
    "\n",
    "1. **Definition:**\n",
    "   - An abstract class is a class that cannot be instantiated on its own and is meant to be subclassed. It may contain both abstract and concrete methods.\n",
    "   - Abstract classes are defined using the `abc` (Abstract Base Classes) module in Python.\n",
    "\n",
    "2. **Abstract Methods:**\n",
    "   - Abstract methods are methods declared in an abstract class but do not have an implementation in the abstract class itself.\n",
    "   - Subclasses must provide concrete implementations for abstract methods.\n",
    "\n",
    "3. **Role in Polymorphism:**\n",
    "   - Abstract classes provide a common interface that multiple subclasses can adhere to.\n",
    "   - They enforce a certain structure in the derived classes, ensuring that they implement specific methods.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interfaces:\n",
    "\n",
    "1. **Definition:**\n",
    "   - Python does not have a specific `interface` keyword. Instead, interfaces are often represented using abstract classes with only abstract methods.\n",
    "   - An interface in Python is essentially an abstract class that consists solely of abstract methods.\n",
    "\n",
    "2. **Role in Polymorphism:**\n",
    "   - Like abstract classes, interfaces define a common set of methods that multiple classes can implement.\n",
    "   - They provide a contract for the expected behavior without specifying how it should be implemented.\n",
    "\n",
    "\n",
    "### Comparisons:\n",
    "\n",
    "1. **Instantiation:**\n",
    "   - Abstract classes can have both abstract and concrete methods, and they can be instantiated (though not directly). Abstract classes can also have attributes.\n",
    "   - Interfaces, being abstract classes with only abstract methods, cannot be instantiated, and they typically don't have attributes.\n",
    "\n",
    "2. **Multiple Inheritance:**\n",
    "   - Python allows a class to inherit from multiple abstract classes, providing a form of multiple inheritance.\n",
    "   - In practice, multiple inheritance can lead to complex class hierarchies, and careful design is required.\n",
    "\n",
    "3. **Use of `ABC` Module:**\n",
    "   - Both abstract classes and interfaces use the `ABC` module for declaring abstract methods.\n",
    "\n",
    "4. **Enforcement:**\n",
    "   - Abstract classes and interfaces both enforce a certain structure on derived classes, ensuring that they implement specific methods.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Abstract class example\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return 3.14 * self.radius * self.radius\n",
    "\n",
    "class Square(Shape):\n",
    "    def __init__(self, side):\n",
    "        self.side = side\n",
    "\n",
    "    def area(self):\n",
    "        return self.side * self.side\n",
    "\n",
    "# Interface example\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class ShapeInterface(ABC):\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "class Circle(ShapeInterface):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return 3.14 * self.radius * self.radius\n",
    "\n",
    "class Square(ShapeInterface):\n",
    "    def __init__(self, side):\n",
    "        self.side = side\n",
    "\n",
    "    def area(self):\n",
    "        return self.side * self.side\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In conclusion, both abstract classes and interfaces in Python serve the purpose of defining common interfaces for multiple classes, allowing for polymorphism. The choice between them often depends on the specific needs of the application and design preferences. Python's flexibility allows developers to use either approach or a combination of both, based on the requirements of the project."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 20. 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": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Lion is a Mammal:\n",
      "Roar!\n",
      "Lion is eating.\n",
      "Lion is sleeping.\n",
      "\n",
      "Eagle is a Bird:\n",
      "Tweet!\n",
      "Eagle is eating.\n",
      "Eagle is sleeping.\n",
      "\n",
      "Snake is a Reptile:\n",
      "Hiss!\n",
      "Snake is eating.\n",
      "Snake is sleeping.\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def make_sound(self):\n",
    "        raise NotImplementedError(\"Subclasses must implement the make_sound method\")\n",
    "\n",
    "    def eat(self):\n",
    "        print(f\"{self.name} is eating.\")\n",
    "\n",
    "    def sleep(self):\n",
    "        print(f\"{self.name} is sleeping.\")\n",
    "\n",
    "class Mammal(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Roar!\")\n",
    "\n",
    "    def give_birth(self):\n",
    "        print(f\"{self.name} is giving birth to live young.\")\n",
    "\n",
    "class Bird(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Tweet!\")\n",
    "\n",
    "    def lay_eggs(self):\n",
    "        print(f\"{self.name} is laying eggs.\")\n",
    "\n",
    "class Reptile(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Hiss!\")\n",
    "\n",
    "    def lay_eggs(self):\n",
    "        print(f\"{self.name} is laying eggs.\")\n",
    "\n",
    "# Polymorphic function to perform actions\n",
    "def perform_actions(animal):\n",
    "    print(f\"\\n{animal.name} is a {type(animal).__name__}:\")\n",
    "    animal.make_sound()\n",
    "    animal.eat()\n",
    "    animal.sleep()\n",
    "\n",
    "# Create instances of different animal types\n",
    "lion = Mammal(\"Lion\")\n",
    "eagle = Bird(\"Eagle\")\n",
    "snake = Reptile(\"Snake\")\n",
    "\n",
    "# Demonstrate polymorphism by calling the common interface methods\n",
    "perform_actions(lion)\n",
    "perform_actions(eagle)\n",
    "perform_actions(snake)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Abstraction:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. What is abstraction in Python, and how does it relate to object-oriented programming?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abstraction in Python, particularly in the context of object-oriented programming (OOP), is the concept of simplifying complex systems by modeling classes based on the essential properties and behaviors they exhibit. It involves focusing on the essential features of an object while ignoring the unnecessary details. Abstraction helps in managing the complexity of large systems by allowing programmers to deal with high-level models of entities without getting into the nitty-gritty details of their implementations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fido says woof!\n",
      "Kitty says meow!\n"
     ]
    }
   ],
   "source": [
    "#for example\n",
    "class Animal:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def speak(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        print(f\"{self.name} says woof!\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        print(f\"{self.name} says meow!\")\n",
    "\n",
    "fido = Dog(\"Fido\")\n",
    "fido.speak()\n",
    "\n",
    "kitty = Cat(\"Kitty\")\n",
    "kitty.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Describe the benefits of abstraction in terms of code organization and complexity reduction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **Simplified Understanding:**\n",
    "   - Abstraction allows developers to focus on the essential aspects of a system while ignoring irrelevant details. This simplifies the mental model of the code, making it easier to understand and reason about.\n",
    "\n",
    "2. **Code Reusability:**\n",
    "   - Abstraction promotes the creation of reusable code components. Once a high-level abstraction is defined, it can be reused in various parts of the program or even in different projects, reducing redundancy and promoting modularity.\n",
    "\n",
    "3. **Isolation of Complexity:**\n",
    "   - Abstraction helps in isolating the complexity of a system by breaking it down into smaller, more manageable components. Each component can be understood and developed independently, making it easier to maintain and update the codebase.\n",
    "\n",
    "4. **Modularity:**\n",
    "   - Abstraction encourages the creation of modular code, where each module represents a distinct functionality or concept. This modularity facilitates collaboration among developers, as they can work on different modules without interfering with each other's code.\n",
    "\n",
    "5. **Ease of Maintenance:**\n",
    "   - Abstracting away unnecessary details and focusing on essential concepts makes the codebase more maintainable. When updates or changes are required, developers can modify or extend the high-level abstractions without affecting the entire system.\n",
    "\n",
    "6. **Enhanced Scalability:**\n",
    "   - Abstraction supports scalability by providing a structure that can accommodate growth without a proportional increase in complexity. New features or components can be added more easily when the underlying abstractions are well-designed.\n",
    "\n",
    "7. **Improved Collaboration:**\n",
    "   - Abstraction facilitates collaboration among team members with different expertise. Developers can work on specific components without needing an in-depth understanding of the entire system, as long as they understand the relevant abstractions.\n",
    "\n",
    "8. **Reduced Bug Introduction:**\n",
    "   - Abstraction helps in reducing the likelihood of introducing bugs when making changes. Since developers interact with well-defined abstractions, they are less likely to inadvertently affect other parts of the system.\n",
    "\n",
    "9. **Enhanced Testing:**\n",
    "   - Testing becomes more effective and manageable with abstraction. Each abstraction can be tested independently, allowing for more focused and thorough testing of specific functionalities.\n",
    "\n",
    "10. **Adaptability to Change:**\n",
    "    - Abstraction makes code more adaptable to changes in requirements or technology. As long as the high-level abstractions remain intact, the underlying implementation details can be modified or replaced without affecting the overall system.\n",
    "\n",
    "In summary, abstraction is a powerful tool for managing complexity in software development, leading to code that is easier to understand, maintain, and extend. It contributes to a more efficient and collaborative development process while promoting code reuse and modularity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. 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 using these classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the circle: 78.54\n",
      "Area of the rectangle: 24\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "import math\n",
    "\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def calculate_area(self):\n",
    "        pass\n",
    "\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",
    "class Rectangle(Shape):\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return self.length * self.width\n",
    "\n",
    "# Example Usage\n",
    "circle = Circle(radius=5)\n",
    "rectangle = Rectangle(length=4, width=6)\n",
    "\n",
    "print(f\"Area of the circle: {circle.calculate_area():.2f}\")\n",
    "print(f\"Area of the rectangle: {rectangle.calculate_area()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Explain the concept of abstract classes in Python and how they are defined using the `abc` module. Provide an example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, an abstract class is a class that cannot be instantiated on its own and is meant to be subclassed by other classes. Abstract classes are used to define a common interface for a group of related classes, ensuring that all derived classes implement certain methods. Python provides the `abc` module (Abstract Base Classes) to work with abstract classes.\n",
    "\n",
    "Here's an explanation of how abstract classes are defined using the `abc` module, along with an example:\n",
    "\n",
    "1. **Import the `ABC` class and the `abstractmethod` decorator:**\n",
    "   - The `ABC` class is a part of the `abc` module and is used as a base class for creating abstract classes.\n",
    "   - The `abstractmethod` decorator is used to declare abstract methods within abstract classes.\n",
    "\n",
    "2. **Define an abstract class:**\n",
    "   - Create a class that inherits from `ABC`.\n",
    "   - Use the `@abstractmethod` decorator to declare abstract methods that must be implemented by the subclasses.\n",
    "\n",
    "3. **Subclass the abstract class:**\n",
    "   - Create one or more classes that inherit from the abstract class.\n",
    "   - Implement all the abstract methods declared in the abstract class.\n",
    "\n",
    "Here's an example:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circle with radius 5\n",
      "Area of the circle: 78.50\n",
      "Rectangle with length 4 and width 6\n",
      "Area of the rectangle: 24\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def calculate_area(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def display_info(self):\n",
    "        pass\n",
    "\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return 3.14 * self.radius ** 2\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Circle with radius {self.radius}\")\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return self.length * self.width\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Rectangle with length {self.length} and width {self.width}\")\n",
    "\n",
    "# Example Usage\n",
    "circle = Circle(radius=5)\n",
    "rectangle = Rectangle(length=4, width=6)\n",
    "\n",
    "circle.display_info()\n",
    "print(f\"Area of the circle: {circle.calculate_area():.2f}\")\n",
    "\n",
    "rectangle.display_info()\n",
    "print(f\"Area of the rectangle: {rectangle.calculate_area()}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. How do abstract classes differ from regular classes in Python? Discuss their use cases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abstract classes and regular classes in Python differ in several ways, primarily in terms of instantiation and the presence of abstract methods. Here are the key differences and their use cases:\n",
    "\n",
    "1. **Instantiation:**\n",
    "   - **Regular Classes:** Instances of regular classes can be created directly. These classes may or may not have methods with default implementations.\n",
    "   - **Abstract Classes:** Instances of abstract classes cannot be created directly. They are meant to be subclassed, and their abstract methods must be implemented in the subclasses.\n",
    "\n",
    "2. **Abstract Methods:**\n",
    "   - **Regular Classes:** Regular classes may have methods with default implementations, but it's not mandatory for all methods to be implemented by subclasses.\n",
    "   - **Abstract Classes:** Abstract classes often have abstract methods (methods without implementations) that must be implemented by any concrete (non-abstract) subclass.\n",
    "\n",
    "3. **Purpose:**\n",
    "   - **Regular Classes:** Regular classes are used to create objects with specific attributes and behaviors. They provide a blueprint for creating instances.\n",
    "   - **Abstract Classes:** Abstract classes are used to define a common interface for a group of related classes. They ensure that all subclasses implement certain methods, providing a way to enforce a consistent structure among subclasses.\n",
    "\n",
    "4. **Use Cases:**\n",
    "   - **Regular Classes:**\n",
    "     - Used when you want to create objects with common attributes and behaviors.\n",
    "     - Suitable for cases where not all methods need to be implemented in every subclass.\n",
    "     - Provides flexibility in terms of method implementation.\n",
    "\n",
    "   - **Abstract Classes:**\n",
    "     - Used when you want to create a base class with some methods that must be implemented by all subclasses.\n",
    "     - Ensures a common interface across multiple classes, making it easier to work with a group of related objects.\n",
    "     - Provides a way to enforce a contract that all subclasses must adhere to.\n",
    "\n",
    "Here's a brief example to illustrate the difference:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some generic sound\n",
      "Area of the circle: 78.50\n"
     ]
    }
   ],
   "source": [
    "# Regular Class\n",
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Some generic sound\")\n",
    "\n",
    "# Abstract Class\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def calculate_area(self):\n",
    "        pass\n",
    "\n",
    "# Concrete Subclass of Shape\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return 3.14 * self.radius ** 2\n",
    "\n",
    "# Example Usage\n",
    "dog = Animal()\n",
    "dog.speak() \n",
    "\n",
    "# shape = Shape()  # This would result in an error since Shape is an abstract class\n",
    "circle = Circle(radius=5)\n",
    "print(f\"Area of the circle: {circle.calculate_area():.2f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Create a Python class for a bank account and demonstrate abstraction by hiding the account balance and providing methods to deposit and withdraw funds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Account holder: Tony Stark\n",
      "Initial balance: ₹1000\n",
      "Deposited ₹500. New balance: ₹1500\n",
      "Withdrew ₹200. New balance: ₹1300\n",
      "Insufficient funds. Withdrawal not possible.\n",
      "Final balance: ₹1300\n"
     ]
    }
   ],
   "source": [
    "class BankAccount:\n",
    "    def __init__(self, account_holder, initial_balance=0):\n",
    "        self.__account_holder = account_holder\n",
    "        self.__balance = initial_balance  # Prefixing with underscore indicates it's a \"private\" attribute\n",
    "\n",
    "    def deposit(self, amount):\n",
    "        if amount > 0:\n",
    "            self.__balance += amount\n",
    "            print(f\"Deposited ₹{amount}. New balance: ₹{self.__balance}\")\n",
    "        else:\n",
    "            print(\"Invalid deposit amount. Please deposit a positive amount.\")\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if amount > 0 and amount <= self.__balance:\n",
    "            self.__balance -= amount\n",
    "            print(f\"Withdrew ₹{amount}. New balance: ₹{self.__balance}\")\n",
    "        elif amount <= 0:\n",
    "            print(\"Invalid withdrawal amount. Please withdraw a positive amount.\")\n",
    "        else:\n",
    "            print(\"Insufficient funds. Withdrawal not possible.\")\n",
    "\n",
    "    def get_balance(self):\n",
    "        return self.__balance\n",
    "\n",
    "    def get_account_holder(self):\n",
    "        return self.__account_holder\n",
    "\n",
    "# Example Usage\n",
    "account1 = BankAccount(\"Tony Stark\", initial_balance=1000)\n",
    "\n",
    "print(f\"Account holder: {account1.get_account_holder()}\")\n",
    "print(f\"Initial balance: ₹{account1.get_balance()}\")\n",
    "\n",
    "account1.deposit(500)\n",
    "account1.withdraw(200)\n",
    "account1.withdraw(1500)  # This should result in an insufficient funds message\n",
    "\n",
    "print(f\"Final balance: ₹{account1.get_balance()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Discuss the concept of interface classes in Python and their role in achieving abstraction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, interface classes are not a built-in feature like in some other programming languages (e.g., Java). However, the concept of interfaces can be emulated using abstract classes or ABCs (Abstract Base Classes) provided by the `abc` module. The role of interface classes, whether implemented using abstract classes or other means, is closely tied to achieving abstraction and defining a contract for classes that implement them.\n",
    "\n",
    "Here are the key points related to interface classes and their role in achieving abstraction:\n",
    "\n",
    "1. **Abstract Base Classes (ABCs):**\n",
    "   - In Python, interface-like behavior is often achieved through abstract classes using the `abc` module.\n",
    "   - Abstract classes can have abstract methods, which are declared without providing an implementation. Subclasses are then required to implement these abstract methods.\n",
    "\n",
    "2. **Defining a Contract:**\n",
    "   - Interface classes define a contract or a set of methods that concrete classes must implement.\n",
    "   - The contract specifies the behavior that classes must exhibit, ensuring a common interface across different implementations.\n",
    "\n",
    "3. **Achieving Abstraction:**\n",
    "   - Interface classes contribute to abstraction by allowing developers to work with high-level, generalized concepts without concerning themselves with the specific details of each implementation.\n",
    "   - Users of classes that implement the interface can interact with objects through the common methods defined in the interface, promoting a simplified and consistent usage pattern.\n",
    "\n",
    "4. **Enforcing Structure:**\n",
    "   - Interface classes help enforce a certain structure among classes that implement them. This ensures that the essential methods are present and adhere to a specific signature, enhancing code reliability and maintainability.\n",
    "\n",
    "5. **Example using Abstract Base Classes (ABCs):**\n",
    "   - Here's a simple example using ABCs to emulate an interface in Python:\n",
    "\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the circle: 78.50\n",
      "Area of the rectangle: 24\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return 3.14 * self.radius ** 2\n",
    "\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",
    "# Example Usage\n",
    "circle = Circle(radius=5)\n",
    "rectangle = Rectangle(length=4, width=6)\n",
    "\n",
    "print(f\"Area of the circle: {circle.area():.2f}\")\n",
    "print(f\"Area of the rectangle: {rectangle.area()}\")\n",
    "     \n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Create a Python class hierarchy for animals and implement abstraction by defining common methods (e.g., `eat()`, `sleep()`) in an abstract base class.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Buddy says Woof!\n",
      "Buddy is eating dog food.\n",
      "Buddy is sleeping in a dog bed.\n",
      "Whiskers says Meow!\n",
      "Whiskers is eating cat food.\n",
      "Whiskers is napping on a sunny windowsill.\n",
      "Dumbo trumpets loudly!\n",
      "Dumbo is munching on leaves and grass.\n",
      "Dumbo is taking a nap in the shade.\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract base class for animals\n",
    "class Animal(ABC):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    @abstractmethod\n",
    "    def speak(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def eat(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def sleep(self):\n",
    "        pass\n",
    "\n",
    "# Concrete subclasses for specific types of animals\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return f\"{self.name} says Woof!\"\n",
    "\n",
    "    def eat(self):\n",
    "        return f\"{self.name} is eating dog food.\"\n",
    "\n",
    "    def sleep(self):\n",
    "        return f\"{self.name} is sleeping in a dog bed.\"\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return f\"{self.name} says Meow!\"\n",
    "\n",
    "    def eat(self):\n",
    "        return f\"{self.name} is eating cat food.\"\n",
    "\n",
    "    def sleep(self):\n",
    "        return f\"{self.name} is napping on a sunny windowsill.\"\n",
    "\n",
    "class Elephant(Animal):\n",
    "    def speak(self):\n",
    "        return f\"{self.name} trumpets loudly!\"\n",
    "\n",
    "    def eat(self):\n",
    "        return f\"{self.name} is munching on leaves and grass.\"\n",
    "\n",
    "    def sleep(self):\n",
    "        return f\"{self.name} is taking a nap in the shade.\"\n",
    "\n",
    "# Example Usage\n",
    "dog = Dog(\"Buddy\")\n",
    "cat = Cat(\"Whiskers\")\n",
    "elephant = Elephant(\"Dumbo\")\n",
    "\n",
    "# Using common methods defined in the abstract base class\n",
    "print(dog.speak())\n",
    "print(dog.eat())\n",
    "print(dog.sleep())\n",
    "\n",
    "print(cat.speak())\n",
    "print(cat.eat())\n",
    "print(cat.sleep())\n",
    "\n",
    "print(elephant.speak())\n",
    "print(elephant.eat())\n",
    "print(elephant.sleep())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Explain the significance of encapsulation in achieving abstraction. Provide examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encapsulation is a fundamental concept in object-oriented programming that involves bundling the data (attributes) and methods (functions) that operate on the data within a single unit, known as a class. This concept plays a significant role in achieving abstraction by hiding the internal details of an object and exposing only what is necessary for external interaction. Encapsulation provides several benefits for achieving abstraction:\n",
    "\n",
    "1. **Data Protection:**\n",
    "   - Encapsulation allows the data (attributes) of an object to be hidden from external access. This protects the integrity of the data and prevents unintended modifications from outside the class.\n",
    "\n",
    "2. **Abstraction of Implementation Details:**\n",
    "   - By encapsulating the implementation details within a class, external users only need to interact with the public interface of the class. This abstracts away the complexity of the internal workings, making it easier for users to understand and use the class.\n",
    "\n",
    "3. **Controlled Access:**\n",
    "   - Encapsulation provides control over access to the internal data of an object. By using access modifiers (such as private, protected, and public), developers can specify which parts of a class are accessible from outside the class. This helps in enforcing data hiding and ensuring that the object is manipulated only through well-defined methods.\n",
    "\n",
    "4. **Promotion of Modularity:**\n",
    "   - Encapsulation promotes modularity by bundling related data and methods together. This modular structure makes it easier to update and maintain the code, as changes to one part of the system are less likely to affect other parts.\n",
    "\n",
    "5. **Prevention of Unintended Interference:**\n",
    "   - Encapsulation helps prevent unintended interference between different parts of a program. Changes made to the internal implementation of a class do not impact external code as long as the public interface remains consistent.\n",
    "\n",
    "Now, let's look at an example to illustrate the significance of encapsulation in achieving abstraction:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Year: 2022\n",
      "Fuel level: 100\n",
      "Driving 50 miles.\n",
      "Fuel level after driving: 95\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    def __init__(self, make, model, year):\n",
    "        self._make = make      \n",
    "        self._model = model\n",
    "        self._year = year\n",
    "        self._fuel = 100        # Initial fuel level\n",
    "\n",
    "    def drive(self, distance):\n",
    "        fuel_needed = distance // 10\n",
    "        if fuel_needed <= self._fuel:\n",
    "            print(f\"Driving {distance} miles.\")\n",
    "            self._fuel -= fuel_needed\n",
    "        else:\n",
    "            print(\"Not enough fuel.\")\n",
    "\n",
    "    def get_fuel_level(self):\n",
    "        return self._fuel\n",
    "\n",
    "# Example Usage\n",
    "my_car = Car(make=\"Toyota\", model=\"Fortuner\", year=2022)\n",
    "\n",
    "# Accessing attributes directly (not recommended, but still possible)\n",
    "print(f\"Year: {my_car._year}\")\n",
    "\n",
    "# Accessing through methods (recommended)\n",
    "print(f\"Fuel level: {my_car.get_fuel_level()}\")\n",
    "\n",
    "my_car.drive(50)\n",
    "print(f\"Fuel level after driving: {my_car.get_fuel_level()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. What is the purpose of abstract methods, and how do they enforce abstraction in Python classes?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abstract methods serve the purpose of defining a method signature in an abstract base class (ABC) without providing an implementation. The responsibility for implementing these abstract methods is left to the concrete subclasses that inherit from the abstract base class. Abstract methods enforce abstraction in Python classes by ensuring that certain methods must be implemented by any class that wants to be considered a concrete subclass of the abstract base class.\n",
    "\n",
    "Here's how abstract methods contribute to achieving abstraction in Python classes:\n",
    "\n",
    "1. **Method Signatures without Implementation:**\n",
    "   - Abstract methods declare the method signature (name, parameters, and return type) without providing the actual code for the method.\n",
    "   - The abstract method acts as a placeholder, indicating that any concrete subclass must provide its own implementation of the method.\n",
    "\n",
    "2. **Forcing Implementation in Subclasses:**\n",
    "   - When a class contains abstract methods, it cannot be instantiated on its own. Instead, it serves as a blueprint or template for concrete subclasses.\n",
    "   - Concrete subclasses must provide implementations for all abstract methods declared in the abstract base class. Failure to do so results in a `TypeError` at runtime.\n",
    "\n",
    "3. **Defining a Common Interface:**\n",
    "   - Abstract methods define a common interface that all concrete subclasses must adhere to.\n",
    "   - This common interface ensures that all subclasses share a certain set of methods, promoting a consistent and predictable usage pattern.\n",
    "\n",
    "4. **Enforcing a Contract:**\n",
    "   - Abstract methods enforce a contract between the abstract base class and its subclasses. This contract specifies the methods that subclasses must implement, ensuring a minimum level of functionality.\n",
    "\n",
    "Here's an example to illustrate the use of abstract methods and how they enforce abstraction:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the circle: 78.50\n",
      "Area of the rectangle: 24\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract base class with an abstract method\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def calculate_area(self):\n",
    "        pass\n",
    "\n",
    "# Concrete subclass implementing the abstract method\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return 3.14 * self.radius ** 2\n",
    "\n",
    "# Concrete subclass implementing the abstract method\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return self.length * self.width\n",
    "\n",
    "# Instantiate objects and use the common interface\n",
    "circle = Circle(radius=5)\n",
    "rectangle = Rectangle(length=4, width=6)\n",
    "\n",
    "print(f\"Area of the circle: {circle.calculate_area():.2f}\")\n",
    "print(f\"Area of the rectangle: {rectangle.calculate_area()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. Create a Python class for a vehicle system and demonstrate abstraction by defining common methods (e.g., `start()`, `stop()`) in an abstract base class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Information about the car: 2023 Toyota Fortuner\n",
      "The car engine is now running.\n",
      "The car engine has been turned off.\n",
      "\n",
      "\n",
      "Information about the motorcycle: 2021 Harley-Davidson Fatboy\n",
      "The motorcycle engine is now running.\n",
      "The motorcycle engine has been turned off.\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract base class for vehicles\n",
    "class Vehicle(ABC):\n",
    "    def __init__(self, make, model, year):\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        self.is_running = False\n",
    "\n",
    "    @abstractmethod\n",
    "    def start(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def stop(self):\n",
    "        pass\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"{self.year} {self.make} {self.model}\"\n",
    "\n",
    "# Concrete subclass for a car\n",
    "class Car(Vehicle):\n",
    "    def __init__(self, make, model, year, num_doors):\n",
    "        super().__init__(make, model, year)\n",
    "        self.num_doors = num_doors\n",
    "\n",
    "    def start(self):\n",
    "        if not self.is_running:\n",
    "            self.is_running = True\n",
    "            print(f\"The car engine is now running.\")\n",
    "        else:\n",
    "            print(\"The car engine is already running.\")\n",
    "\n",
    "    def stop(self):\n",
    "        if self.is_running:\n",
    "            self.is_running = False\n",
    "            print(f\"The car engine has been turned off.\")\n",
    "        else:\n",
    "            print(\"The car engine is already off.\")\n",
    "\n",
    "# Concrete subclass for a motorcycle\n",
    "class Motorcycle(Vehicle):\n",
    "    def __init__(self, make, model, year):\n",
    "        super().__init__(make, model, year)\n",
    "\n",
    "    def start(self):\n",
    "        if not self.is_running:\n",
    "            self.is_running = True\n",
    "            print(f\"The motorcycle engine is now running.\")\n",
    "        else:\n",
    "            print(\"The motorcycle engine is already running.\")\n",
    "\n",
    "    def stop(self):\n",
    "        if self.is_running:\n",
    "            self.is_running = False\n",
    "            print(f\"The motorcycle engine has been turned off.\")\n",
    "        else:\n",
    "            print(\"The motorcycle engine is already off.\")\n",
    "\n",
    "# Example Usage\n",
    "car = Car(make=\"Toyota\", model=\"Fortuner\", year=2023, num_doors=4)\n",
    "motorcycle = Motorcycle(make=\"Harley-Davidson\", model=\"Fatboy\", year=2021)\n",
    "\n",
    "print(f\"Information about the car: {car.get_info()}\")\n",
    "car.start()\n",
    "car.stop()\n",
    "\n",
    "print(\"\\n\")\n",
    "\n",
    "print(f\"Information about the motorcycle: {motorcycle.get_info()}\")\n",
    "motorcycle.start()\n",
    "motorcycle.stop()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12. Describe the use of abstract properties in Python and how they can be employed in abstract classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, abstract properties are used in abstract classes to define a common interface for properties (attributes) that must be implemented by concrete subclasses. Abstract properties are created using the `@property` decorator in conjunction with the `@abstractmethod` decorator from the `abc` (Abstract Base Classes) module.\n",
    "\n",
    "Here's how abstract properties can be employed in abstract classes:\n",
    "\n",
    "1. **Define Abstract Properties:**\n",
    "   - Use the `@property` decorator along with `@abstractmethod` to declare an abstract property in an abstract base class.\n",
    "   - Abstract properties do not have an implementation, and their purpose is to enforce that concrete subclasses provide their own implementations.\n",
    "\n",
    "2. **Implement in Subclasses:**\n",
    "   - Concrete subclasses of the abstract base class must provide their own implementations for the abstract properties.\n",
    "   - Failure to provide an implementation for an abstract property in a concrete subclass results in a `TypeError` at runtime.\n",
    "\n",
    "3. **Common Interface for Properties:**\n",
    "   - Abstract properties help in defining a common interface for attributes that must be present in all subclasses.\n",
    "   - This promotes a consistent structure across different implementations and ensures that specific attributes are available in each subclass.\n",
    "\n",
    "Here's an example to illustrate the use of abstract properties in abstract classes:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the circle: 78.50\n",
      "Area of the rectangle: 24\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract base class with abstract property\n",
    "class Shape(ABC):\n",
    "    @property\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "# Concrete subclass implementing the abstract property\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self._radius = radius\n",
    "\n",
    "    @property\n",
    "    def area(self):\n",
    "        return 3.14 * self._radius ** 2\n",
    "\n",
    "# Concrete subclass implementing the abstract property\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, length, width):\n",
    "        self._length = length\n",
    "        self._width = width\n",
    "\n",
    "    @property\n",
    "    def area(self):\n",
    "        return self._length * self._width\n",
    "\n",
    "# Example Usage\n",
    "circle = Circle(radius=5)\n",
    "rectangle = Rectangle(length=4, width=6)\n",
    "\n",
    "print(f\"Area of the circle: {circle.area:.2f}\")\n",
    "print(f\"Area of the rectangle: {rectangle.area}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13. Create a Python class hierarchy for employees in a company (e.g., manager, developer, designer) and implement abstraction by defining a common `get_salary()` method.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tony Stark's Salary: ₹92000.0\n",
      "Bruce wane's Salary: ₹70000\n",
      "Steve Evans's Salary: ₹78000\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract base class for employees\n",
    "class Employee(ABC):\n",
    "    def __init__(self, name, employee_id):\n",
    "        self.name = name\n",
    "        self.employee_id = employee_id\n",
    "\n",
    "    @abstractmethod\n",
    "    def get_salary(self):\n",
    "        pass\n",
    "\n",
    "# Concrete subclass for a manager\n",
    "class Manager(Employee):\n",
    "    def __init__(self, name, employee_id, salary, bonus_percentage):\n",
    "        super().__init__(name, employee_id)\n",
    "        self.salary = salary\n",
    "        self.bonus_percentage = bonus_percentage\n",
    "\n",
    "    def get_salary(self):\n",
    "        bonus_amount = (self.bonus_percentage / 100) * self.salary\n",
    "        return self.salary + bonus_amount\n",
    "\n",
    "# Concrete subclass for a developer\n",
    "class Developer(Employee):\n",
    "    def __init__(self, name, employee_id, salary, programming_language):\n",
    "        super().__init__(name, employee_id)\n",
    "        self.salary = salary\n",
    "        self.programming_language = programming_language\n",
    "\n",
    "    def get_salary(self):\n",
    "        return self.salary\n",
    "\n",
    "# Concrete subclass for a designer\n",
    "class Designer(Employee):\n",
    "    def __init__(self, name, employee_id, salary, years_of_experience):\n",
    "        super().__init__(name, employee_id)\n",
    "        self.salary = salary\n",
    "        self.years_of_experience = years_of_experience\n",
    "\n",
    "    def get_salary(self):\n",
    "        experience_bonus = min(self.years_of_experience, 5) * 1000\n",
    "        return self.salary + experience_bonus\n",
    "\n",
    "# Example Usage\n",
    "manager = Manager(name=\"Tony Stark\", employee_id=101, salary=80000, bonus_percentage=15)\n",
    "developer = Developer(name=\"Bruce wane\", employee_id=102, salary=70000, programming_language=\"Python\")\n",
    "designer = Designer(name=\"Steve Evans\", employee_id=103, salary=75000, years_of_experience=3)\n",
    "\n",
    "print(f\"{manager.name}'s Salary: ₹{manager.get_salary()}\")\n",
    "print(f\"{developer.name}'s Salary: ₹{developer.get_salary()}\")\n",
    "print(f\"{designer.name}'s Salary: ₹{designer.get_salary()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 14. Discuss the differences between abstract classes and concrete classes in Python, including their instantiation.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abstract classes and concrete classes in Python serve different purposes and have distinct characteristics. Let's discuss the differences between these two types of classes, including their instantiation:\n",
    "\n",
    "### Abstract Classes:\n",
    "\n",
    "1. **Purpose:**\n",
    "   - **Abstract Classes:** They are meant to serve as a blueprint for other classes. They may define abstract methods (methods without implementations) that must be implemented by concrete subclasses.\n",
    "\n",
    "2. **Instantiation:**\n",
    "   - **Abstract Classes:** Cannot be instantiated on their own. They are intended to be subclassed, and instances of concrete subclasses are created instead.\n",
    "\n",
    "3. **Abstract Methods:**\n",
    "   - **Abstract Classes:** May have abstract methods, which are declared using the `@abstractmethod` decorator. Concrete subclasses must provide implementations for these abstract methods.\n",
    "\n",
    "4. **Example:**\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "   from abc import ABC, abstractmethod\n",
    "\n",
    "   class Shape(ABC):\n",
    "       @abstractmethod\n",
    "       def area(self):\n",
    "           pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concrete Classes:\n",
    "\n",
    "1. **Purpose:**\n",
    "   - **Concrete Classes:** They are meant to be instantiated directly. They provide concrete implementations for methods and may inherit from abstract classes or other concrete classes.\n",
    "\n",
    "2. **Instantiation:**\n",
    "   - **Concrete Classes:** Can be instantiated on their own. Instances are created using the class name, and they may or may not inherit from other classes.\n",
    "\n",
    "3. **Abstract Methods:**\n",
    "   - **Concrete Classes:** Do not have abstract methods. They provide concrete implementations for all methods declared in their class hierarchy.\n",
    "\n",
    "4. **Example:**\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instantiation Differences:\n",
    "\n",
    "1. **Abstract Classes:**\n",
    "   - **Cannot be instantiated:** Attempts to create an instance of an abstract class directly will result in a `TypeError`.\n",
    "   - **Serve as blueprints:** Abstract classes provide a template for concrete subclasses, enforcing a certain structure among subclasses.\n",
    "\n",
    "2. **Concrete Classes:**\n",
    "   - **Can be instantiated:** Instances of concrete classes can be created directly using the class name.\n",
    "   - **Provide specific implementations:** Concrete classes define specific behaviors and may inherit from abstract classes or other concrete classes.\n",
    "\n",
    "**Example:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Abstract class\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "# Concrete subclass\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",
    "# Instantiation\n",
    "# shape = Shape()  # Error: Cannot instantiate an abstract class\n",
    "rectangle = Rectangle(length=4, width=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15. Explain the concept of abstract data types (ADTs) and their role in achieving abstraction in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abstract Data Types (ADTs) are a conceptual way of organizing and structuring data in a program based on its behavior and operations, rather than its implementation details. ADTs provide a high-level specification for data and operations on that data, emphasizing what operations can be performed rather than how they are implemented. The key role of ADTs is to achieve abstraction, allowing developers to work with data structures at a higher level without being concerned with the internal details.\n",
    "\n",
    "Here are the key aspects of ADTs and their role in achieving abstraction in Python:\n",
    "\n",
    "1. **High-Level Specification:**\n",
    "   - ADTs define a set of operations that can be performed on the data they encapsulate. These operations represent the essential behaviors associated with the data type.\n",
    "\n",
    "2. **Separation of Concerns:**\n",
    "   - ADTs separate the interface (what the data type does) from the implementation (how it achieves those operations). This separation allows changes to the implementation without affecting the code that uses the data type.\n",
    "\n",
    "3. **Encapsulation:**\n",
    "   - ADTs encapsulate the data and the operations on that data within a single unit. This encapsulation provides a way to control access to the data and ensures that the internal details are hidden from external code.\n",
    "\n",
    "4. **Promotion of Modularity:**\n",
    "   - ADTs promote modularity by encapsulating related data and operations. This modular structure makes it easier to design, understand, and maintain code, as changes to one part of the system are less likely to impact other parts.\n",
    "\n",
    "5. **Abstraction of Complexity:**\n",
    "   - ADTs abstract away the complexity of the underlying data structures and algorithms. This allows developers to work with data at a higher level, focusing on the desired functionality rather than the nitty-gritty details of how it is implemented.\n",
    "\n",
    "6. **Common Examples:**\n",
    "   - Examples of common ADTs include stacks, queues, lists, sets, maps, and trees. Each ADT defines a set of operations that can be performed on the associated data structure.\n",
    "\n",
    "7. **Python's Built-in ADTs:**\n",
    "   - Python provides built-in ADTs through its standard library, such as lists, sets, dictionaries, and tuples. These data types come with well-defined operations, and users interact with them based on their high-level specifications.\n",
    "\n",
    "8. **User-Defined ADTs:**\n",
    "   - Developers can also create their own user-defined ADTs in Python by using classes. For example, a developer might define a `Queue` class with methods like `enqueue` and `dequeue`, encapsulating the behavior of a queue data structure.\n",
    "\n",
    "Here's a simplified example to illustrate the concept of an ADT in Python:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Example of a simple ADT for a Stack\n",
    "class Stack:\n",
    "    def __init__(self):\n",
    "        self.items = []\n",
    "\n",
    "    def push(self, item):\n",
    "        self.items.append(item)\n",
    "\n",
    "    def pop(self):\n",
    "        if not self.is_empty():\n",
    "            return self.items.pop()\n",
    "\n",
    "    def is_empty(self):\n",
    "        return len(self.items) == 0\n",
    "\n",
    "# Example Usage\n",
    "stack = Stack()\n",
    "stack.push(1)\n",
    "stack.push(2)\n",
    "stack.push(3)\n",
    "\n",
    "while not stack.is_empty():\n",
    "    print(stack.pop())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 16. Create a Python class for a computer system, demonstrating abstraction by defining common methods (e.g., `power_on()`, `shutdown()`) in an abstract base class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The desktop computer (Dell Inspiron) is powering on.\n",
      "The desktop computer (Dell Inspiron) is shutting down.\n",
      "\n",
      "\n",
      "The laptop (HP Envy) is powering on.\n",
      "The laptop (HP Envy) is shutting down.\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract base class for a computer system\n",
    "class ComputerSystem(ABC):\n",
    "    def __init__(self, brand, model):\n",
    "        self.brand = brand\n",
    "        self.model = model\n",
    "        self.is_powered_on = False\n",
    "\n",
    "    @abstractmethod\n",
    "    def power_on(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def shutdown(self):\n",
    "        pass\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"{self.brand} {self.model}\"\n",
    "\n",
    "# Concrete subclass for a desktop computer\n",
    "class DesktopComputer(ComputerSystem):\n",
    "    def __init__(self, brand, model, monitor_size):\n",
    "        super().__init__(brand, model)\n",
    "        self.monitor_size = monitor_size\n",
    "\n",
    "    def power_on(self):\n",
    "        if not self.is_powered_on:\n",
    "            self.is_powered_on = True\n",
    "            print(f\"The desktop computer ({self.get_info()}) is powering on.\")\n",
    "        else:\n",
    "            print(\"The desktop computer is already powered on.\")\n",
    "\n",
    "    def shutdown(self):\n",
    "        if self.is_powered_on:\n",
    "            self.is_powered_on = False\n",
    "            print(f\"The desktop computer ({self.get_info()}) is shutting down.\")\n",
    "        else:\n",
    "            print(\"The desktop computer is already powered off.\")\n",
    "\n",
    "# Concrete subclass for a laptop\n",
    "class Laptop(ComputerSystem):\n",
    "    def __init__(self, brand, model, screen_size):\n",
    "        super().__init__(brand, model)\n",
    "        self.screen_size = screen_size\n",
    "\n",
    "    def power_on(self):\n",
    "        if not self.is_powered_on:\n",
    "            self.is_powered_on = True\n",
    "            print(f\"The laptop ({self.get_info()}) is powering on.\")\n",
    "        else:\n",
    "            print(\"The laptop is already powered on.\")\n",
    "\n",
    "    def shutdown(self):\n",
    "        if self.is_powered_on:\n",
    "            self.is_powered_on = False\n",
    "            print(f\"The laptop ({self.get_info()}) is shutting down.\")\n",
    "        else:\n",
    "            print(\"The laptop is already powered off.\")\n",
    "\n",
    "# Example Usage\n",
    "desktop = DesktopComputer(brand=\"Dell\", model=\"Inspiron\", monitor_size=\"24 inches\")\n",
    "laptop = Laptop(brand=\"HP\", model=\"Envy\", screen_size=\"15.6 inches\")\n",
    "\n",
    "desktop.power_on()\n",
    "desktop.shutdown()\n",
    "\n",
    "print(\"\\n\")\n",
    "\n",
    "laptop.power_on()\n",
    "laptop.shutdown()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 17. Discuss the benefits of using abstraction in large-scale software development projects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abstraction plays a crucial role in large-scale software development projects, offering a range of benefits that contribute to the efficiency, maintainability, and scalability of the project. Here are several advantages of using abstraction in such projects:\n",
    "\n",
    "1. **Complexity Management:**\n",
    "   - Abstraction allows developers to deal with complex systems by breaking them down into simpler, more manageable components. This makes it easier to understand, design, and maintain large-scale software.\n",
    "\n",
    "2. **Modularity and Reusability:**\n",
    "   - Abstraction promotes modularity by encapsulating functionality within well-defined units. These modules can be reused in different parts of the project or even in other projects, leading to a more efficient and scalable development process.\n",
    "\n",
    "3. **Encapsulation of Implementation Details:**\n",
    "   - Abstraction enables the hiding of implementation details. Developers interact with high-level interfaces, focusing on what each component does rather than how it achieves its functionality. This encapsulation reduces the risk of unintended dependencies and allows for easier updates or replacements of components.\n",
    "\n",
    "4. **Consistent Interfaces:**\n",
    "   - Abstraction helps in defining consistent interfaces for components or modules. This ensures that different parts of the system communicate in a standardized way, making it easier to integrate and maintain the software over time.\n",
    "\n",
    "5. **Team Collaboration:**\n",
    "   - Abstraction facilitates collaboration among development teams. By defining clear interfaces and contracts between components, teams can work independently on different parts of the project without extensive knowledge of each other's internal implementations.\n",
    "\n",
    "6. **Reduced Cognitive Load:**\n",
    "   - Abstraction reduces the cognitive load on developers by allowing them to focus on high-level concepts rather than getting bogged down in implementation details. This results in clearer and more maintainable code.\n",
    "\n",
    "7. **Adaptability to Changes:**\n",
    "   - Large-scale software projects often undergo changes and updates. Abstraction allows for easier adaptation to changes, as modifications can be confined to specific modules without affecting the entire system.\n",
    "\n",
    "8. **Testing and Debugging:**\n",
    "   - Abstraction aids in testing and debugging by isolating components. Unit testing becomes more straightforward, and debugging efforts are focused on specific modules rather than the entire system, leading to quicker and more effective bug resolution.\n",
    "\n",
    "9. **Code Maintainability:**\n",
    "   - Abstraction improves code maintainability by providing a clear structure and separation of concerns. When developers need to make modifications or fix issues, they can do so with a better understanding of the system's organization, leading to more efficient maintenance.\n",
    "\n",
    "10. **Scalability:**\n",
    "    - Abstraction supports scalability by allowing developers to add new features or expand functionality without disrupting existing components. New modules can be integrated seamlessly, and the overall architecture can evolve to accommodate growth.\n",
    "\n",
    "11. **Documentation and Communication:**\n",
    "    - Abstraction serves as a form of self-documentation. Well-abstracted code communicates the intentions and functionalities of components effectively, making it easier for developers to understand and contribute to the project.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 18. Explain how abstraction enhances code reusability and modularity in Python programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abstraction enhances code reusability and modularity in Python programs by providing a way to create well-defined interfaces and encapsulate implementation details. Here's how abstraction contributes to these aspects:\n",
    "\n",
    "### Code Reusability:\n",
    "\n",
    "1. **Abstract Classes and Interfaces:**\n",
    "   - Python allows the creation of abstract classes using the `abc` module. Abstract classes can define abstract methods, creating a blueprint for functionality without providing implementations.\n",
    "   - By inheriting from abstract classes or implementing abstract methods, subclasses can reuse the common interface, ensuring consistency across different implementations.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return 3.14 * self.radius ** 2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **Inheritance:**\n",
    "   - Inheritance is a form of code reuse where a subclass inherits attributes and methods from a superclass.\n",
    "   - This promotes reuse of common functionality and attributes while allowing for specialization in individual subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        pass\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. **Composition:**\n",
    "   - Abstraction also enables code reuse through composition, where classes can be composed of instances of other classes. This allows for a flexible and modular design.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Engine:\n",
    "    def start(self):\n",
    "        print(\"Engine starting.\")\n",
    "\n",
    "class Car:\n",
    "    def __init__(self):\n",
    "           self.engine = Engine()\n",
    "    def start(self):\n",
    "        print(\"Car starting.\")\n",
    "        self.engine.start()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modularity:\n",
    "\n",
    "1. **Encapsulation:**\n",
    "   - Abstraction in Python supports encapsulation, where data and methods are encapsulated within a class. This encapsulation helps define clear boundaries between different modules, promoting modularity.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Calculator:\n",
    "    def add(self, a, b):\n",
    "        return a + b\n",
    "\n",
    "class MathOperations:\n",
    "    def square(self, x):\n",
    "        return x ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.Collaborative Development:\n",
    "\n",
    "Abstraction facilitates collaborative development by allowing different developers or teams to work on independent modules without needing extensive knowledge of each other's code. This leads to more modular and maintainable projects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 19. Create a Python class for a library system, implementing abstraction by defining common methods (e.g., `add_book()`, `borrow_book()`) in an abstract base class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book 'The Great Gatsby' by F. Scott Fitzgerald added to the library.\n",
      "Book 'To Kill a Mockingbird' by Harper Lee added to the library.\n",
      "Book 'The Catcher in the Rye' by J.D. Salinger added to the library.\n",
      "Library Catalog:\n",
      "The Great Gatsby by F. Scott Fitzgerald - Status: Available\n",
      "To Kill a Mockingbird by Harper Lee - Status: Available\n",
      "The Catcher in the Rye by J.D. Salinger - Status: Available\n",
      "Book 'The Great Gatsby' has been borrowed.\n",
      "Book 'The Catcher in the Rye' has been borrowed.\n",
      "Library Catalog:\n",
      "The Great Gatsby by F. Scott Fitzgerald - Status: Available\n",
      "To Kill a Mockingbird by Harper Lee - Status: Available\n",
      "The Catcher in the Rye by J.D. Salinger - Status: Available\n",
      "Book 'The Great Gatsby' has been returned.\n",
      "Library Catalog:\n",
      "The Great Gatsby by F. Scott Fitzgerald - Status: Available\n",
      "To Kill a Mockingbird by Harper Lee - Status: Available\n",
      "The Catcher in the Rye by J.D. Salinger - Status: Available\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract base class for the Library System\n",
    "class LibrarySystem(ABC):\n",
    "    def __init__(self):\n",
    "        self.books = {}  # Dictionary to store books with their availability status\n",
    "\n",
    "    @abstractmethod\n",
    "    def add_book(self, book_title, author):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def borrow_book(self, book_title):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def return_book(self, book_title):\n",
    "        pass\n",
    "\n",
    "    def list_books(self):\n",
    "        print(\"Library Catalog:\")\n",
    "        for book_title, availability in self.books.items():\n",
    "            status = \"Available\" if availability else \"Borrowed\"\n",
    "            print(f\"{book_title} by {self.books[book_title]['author']} - Status: {status}\")\n",
    "\n",
    "# Concrete subclass for the Library System\n",
    "class SimpleLibrarySystem(LibrarySystem):\n",
    "    def add_book(self, book_title, author):\n",
    "        if book_title not in self.books:\n",
    "            self.books[book_title] = {'author': author, 'available': True}\n",
    "            print(f\"Book '{book_title}' by {author} added to the library.\")\n",
    "        else:\n",
    "            print(f\"Book '{book_title}' already exists in the library.\")\n",
    "\n",
    "    def borrow_book(self, book_title):\n",
    "        if book_title in self.books and self.books[book_title]['available']:\n",
    "            self.books[book_title]['available'] = False\n",
    "            print(f\"Book '{book_title}' has been borrowed.\")\n",
    "        elif book_title in self.books and not self.books[book_title]['available']:\n",
    "            print(f\"Book '{book_title}' is currently not available. It is already borrowed.\")\n",
    "        else:\n",
    "            print(f\"Book '{book_title}' does not exist in the library.\")\n",
    "\n",
    "    def return_book(self, book_title):\n",
    "        if book_title in self.books and not self.books[book_title]['available']:\n",
    "            self.books[book_title]['available'] = True\n",
    "            print(f\"Book '{book_title}' has been returned.\")\n",
    "        elif book_title in self.books and self.books[book_title]['available']:\n",
    "            print(f\"Book '{book_title}' is already available in the library.\")\n",
    "        else:\n",
    "            print(f\"Book '{book_title}' does not exist in the library.\")\n",
    "\n",
    "# Example Usage\n",
    "library_system = SimpleLibrarySystem()\n",
    "\n",
    "library_system.add_book(\"The Great Gatsby\", \"F. Scott Fitzgerald\")\n",
    "library_system.add_book(\"To Kill a Mockingbird\", \"Harper Lee\")\n",
    "library_system.add_book(\"The Catcher in the Rye\", \"J.D. Salinger\")\n",
    "\n",
    "library_system.list_books()\n",
    "\n",
    "library_system.borrow_book(\"The Great Gatsby\")\n",
    "library_system.borrow_book(\"The Catcher in the Rye\")\n",
    "\n",
    "library_system.list_books()\n",
    "\n",
    "library_system.return_book(\"The Great Gatsby\")\n",
    "\n",
    "library_system.list_books()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 20. Describe the concept of method abstraction in Python and how it relates to polymorphism."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method abstraction in Python involves using abstract methods and classes to define a common interface for classes that share a certain set of behaviors. This concept is closely related to polymorphism, a fundamental principle in object-oriented programming. Let's explore how method abstraction and polymorphism are interconnected in Python:\n",
    "\n",
    "### Method Abstraction:\n",
    "\n",
    "1. **Abstract Base Classes (ABCs):**\n",
    "   - Python provides the `abc` module, which allows the creation of abstract base classes. Abstract base classes can contain abstract methods—methods without implementations.\n",
    "   - Abstract methods define a common interface that concrete subclasses must implement.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "2. **Common Interface:**\n",
    "   - Abstract methods in an abstract base class define a common interface for classes that inherit from it. Concrete subclasses are required to provide their own implementations for these abstract methods.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "    def area(self):\n",
    "        return 3.14 * self.radius ** 2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. **Enforcing Contracts:**\n",
    "   - Method abstraction enforces contracts between abstract classes and their subclasses. Subclasses must adhere to the defined interface, ensuring a consistent structure across different implementations.\n",
    "\n",
    "### Polymorphism:\n",
    "\n",
    "1. **Method Overriding:**\n",
    "   - Polymorphism allows objects of different classes to be treated as objects of a common base class. In Python, this often involves method overriding, where a subclass provides its own implementation of a method defined in the superclass.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "    def area(self):\n",
    "        return self.length * self.width\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **Dynamic Dispatch:**\n",
    "   - Python supports dynamic dispatch, meaning that the method to be called is determined at runtime. When a method is called on an object, the interpreter dynamically looks up the appropriate method based on the actual type of the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area: 78.5\n",
      "Area: 24\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def print_area(shape):\n",
    "    print(f\"Area: {shape.area()}\")\n",
    "\n",
    "circle = Circle(radius=5)\n",
    "rectangle = Rectangle(length=4, width=6)\n",
    "\n",
    "print_area(circle)      # Dynamically calls the area method of Circle\n",
    "print_area(rectangle)   # Dynamically calls the area method of Rectangle\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. **Polymorphic Behavior:**\n",
    "   - Method abstraction, combined with method overriding, leads to polymorphic behavior. Objects of different classes can respond to the same method call in a way that is appropriate for their specific type.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area: 78.5\n",
      "Area: 24\n"
     ]
    }
   ],
   "source": [
    "\n",
    "shapes = [circle, rectangle]\n",
    "\n",
    "for shape in shapes:\n",
    "    print_area(shape)  # Polymorphic behavior based on the actual type of each shape\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Relationship:\n",
    "\n",
    "1. **Common Interface for Polymorphism:**\n",
    "   - Method abstraction provides a common interface through abstract methods, ensuring that different classes have a consistent structure.\n",
    "   - Polymorphism allows objects of these classes to be treated uniformly, leading to more generic and reusable code.\n",
    "\n",
    "2. **Flexible and Extensible Code:**\n",
    "   - Method abstraction and polymorphism together create a flexible and extensible code structure. New classes can be added without modifying existing code, as long as they adhere to the common interface defined by abstract classes.\n",
    "\n",
    "3. **Promoting Code Maintenance:**\n",
    "   - Abstracting methods and promoting polymorphic behavior make the code more maintainable. Changes to a class's implementation can be made without affecting code that uses the class, as long as the common interface is preserved.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Composition:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Explain the concept of composition in Python and how it is used to build complex objects from simpler ones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, composition is a programming concept that involves constructing complex objects by combining simpler ones. It is a way to achieve code reuse and modularity by creating classes that are composed of other classes or objects. Unlike inheritance, which involves creating a hierarchy of classes, composition allows you to build relationships between classes without relying on inheritance.\n",
    "\n",
    "The basic idea behind composition is to create instances of one class within another class, allowing you to leverage the functionality of existing classes to build more complex objects. This is often done by including instances of other classes as attributes of the composing class.\n",
    "\n",
    "Let's look at a simple example to illustrate the concept of composition:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car is starting...\n",
      "Engine started\n"
     ]
    }
   ],
   "source": [
    "class Engine:\n",
    "    def start(self):\n",
    "        print(\"Engine started\")\n",
    "\n",
    "class Car:\n",
    "    def __init__(self):\n",
    "        self.engine = Engine()  # Composition: Car has an Engine\n",
    "\n",
    "    def start(self):\n",
    "        print(\"Car is starting...\")\n",
    "        self.engine.start()\n",
    "\n",
    "# Create a Car instance and start it\n",
    "my_car = Car()\n",
    "my_car.start()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Describe the difference between composition and inheritance in object-oriented programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Composition and inheritance are two fundamental concepts in object-oriented programming (OOP) that allow for code reuse and the creation of relationships between classes. Here's a breakdown of the key differences between composition and inheritance:\n",
    "\n",
    "### Composition:\n",
    "\n",
    "1. **Relationship Type:**\n",
    "   - **Has-a Relationship:** Composition represents a \"has-a\" relationship between classes. It involves one class containing an instance of another class as a member.\n",
    "\n",
    "2. **Code Structure:**\n",
    "   - **Object Inclusion:** In composition, the composed class includes objects of other classes as attributes.\n",
    "\n",
    "3. **Flexibility:**\n",
    "   - **More Flexible:** Composition is generally considered more flexible than inheritance. You can change the behavior of a class by modifying the objects it is composed of, without affecting the rest of the code.\n",
    "\n",
    "4. **Code Reusability:**\n",
    "   - **Promotes Code Reusability:** Composition promotes code reuse by allowing the reuse of existing classes in new contexts.\n",
    "\n",
    "5. **Example:**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car is starting...\n",
      "Engine started\n"
     ]
    }
   ],
   "source": [
    "class Engine:\n",
    "    def start(self):\n",
    "        print(\"Engine started\")\n",
    "\n",
    "class Car:\n",
    "    def __init__(self):\n",
    "        self.engine = Engine()  # Composition: Car has an Engine\n",
    "    def start(self):\n",
    "        print(\"Car is starting...\")\n",
    "        self.engine.start()\n",
    "my_car = Car()\n",
    "my_car.start()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inheritance:\n",
    "\n",
    "1. **Relationship Type:**\n",
    "   - **Is-a Relationship:** Inheritance represents an \"is-a\" relationship between classes. It involves creating a new class by inheriting attributes and behaviors from an existing class.\n",
    "\n",
    "2. **Code Structure:**\n",
    "   - **Class Hierarchy:** Inheritance creates a hierarchy of classes, where a subclass inherits attributes and methods from a superclass.\n",
    "\n",
    "3. **Flexibility:**\n",
    "   - **Less Flexible:** Inheritance can lead to a more rigid class structure, and changes to a superclass can affect all its subclasses.\n",
    "\n",
    "4. **Code Reusability:**\n",
    "   - **Reuses Code from Superclass:** Inheritance allows code reuse by inheriting attributes and behaviors from a superclass. However, it can also lead to the diamond problem and other issues.\n",
    "\n",
    "5. **Example:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Meow!\")\n",
    "\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "dog.speak()\n",
    "cat.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Create a Python class called `Author` with attributes for name and birthdate. Then, create a `Book` class that contains an instance of `Author` as a composition. Provide an example of creating a `Book` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Title: Ikigai\n",
      "Author: Tony Stark\n",
      "Birthdate of Author: 1995-07-11\n",
      "Publication Year: 2022\n"
     ]
    }
   ],
   "source": [
    "class Author:\n",
    "    def __init__(self, name, birthdate):\n",
    "        self.name = name\n",
    "        self.birthdate = birthdate\n",
    "\n",
    "class Book:\n",
    "    def __init__(self, title, author, publication_year):\n",
    "        self.title = title\n",
    "        self.author = author  # Composition: Book has an Author\n",
    "        self.publication_year = publication_year\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Title: {self.title}\")\n",
    "        print(f\"Author: {self.author.name}\")\n",
    "        print(f\"Birthdate of Author: {self.author.birthdate}\")\n",
    "        print(f\"Publication Year: {self.publication_year}\")\n",
    "\n",
    "# Example of creating an Author\n",
    "author_example = Author(name=\"Tony Stark\", birthdate=\"1995-07-11\")\n",
    "\n",
    "# Example of creating a Book with the Author as part of the composition\n",
    "book_example = Book(title=\"Ikigai\", author=author_example, publication_year=2022)\n",
    "\n",
    "# Displaying information about the Book\n",
    "book_example.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Discuss the benefits of using composition over inheritance in Python, especially in terms of code flexibility and reusability.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Composition provides several advantages over inheritance:\n",
    "\n",
    "**Flexibility:** With composition, you can easily change the behavior of a class by modifying the objects it is composed of, without affecting the rest of the code.\n",
    "\n",
    "**Code Reusability:** You can reuse existing classes in new contexts, promoting modular and reusable code.\n",
    "\n",
    "**Maintainability:** Changes to the internal implementation of a composed class do not affect the classes that use it.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. How can you implement composition in Python classes? Provide examples of using composition to create complex objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To implement composition in Python classes, we include instances of other classes as attributes within a class. This allows you to build more complex objects by combining simpler ones. Here are examples demonstrating composition in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car is starting...\n",
      "Engine started\n"
     ]
    }
   ],
   "source": [
    "class Engine:\n",
    "    def start(self):\n",
    "        print(\"Engine started\")\n",
    "\n",
    "class Car:\n",
    "    def __init__(self, engine):\n",
    "        self.engine = engine  # Composition: Car has an Engine\n",
    "\n",
    "    def start(self):\n",
    "        print(\"Car is starting...\")\n",
    "        self.engine.start()\n",
    "\n",
    "# Creating instances of the classes\n",
    "my_engine = Engine()\n",
    "my_car = Car(engine=my_engine)\n",
    "\n",
    "# Using composition to start the car\n",
    "my_car.start()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Create a Python class hierarchy for a music player system, using composition to represent playlists and songs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Playing all songs in the playlist 'Kutty story':\n",
      "Playing: Hukum by Anirudh\n",
      "Playing: Vathi comming by Anirudh\n",
      "Playing all songs in the playlist 'Mix':\n",
      "Playing: Hukum by Anirudh\n"
     ]
    }
   ],
   "source": [
    "class Song:\n",
    "    def __init__(self, title, artist, duration):\n",
    "        self.title = title\n",
    "        self.artist = artist\n",
    "        self.duration = duration\n",
    "\n",
    "    def play(self):\n",
    "        print(f\"Playing: {self.title} by {self.artist}\")\n",
    "\n",
    "class Playlist:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.songs = []  # Composition: Playlist has a list of Song objects\n",
    "\n",
    "    def add_song(self, song):\n",
    "        self.songs.append(song)\n",
    "\n",
    "    def play_all(self):\n",
    "        print(f\"Playing all songs in the playlist '{self.name}':\")\n",
    "        for song in self.songs:\n",
    "            song.play()\n",
    "\n",
    "class MusicPlayer:\n",
    "    def __init__(self):\n",
    "        self.playlists = []  # Composition: MusicPlayer has a list of Playlist objects\n",
    "\n",
    "    def create_playlist(self, name):\n",
    "        playlist = Playlist(name)\n",
    "        self.playlists.append(playlist)\n",
    "        return playlist\n",
    "\n",
    "# Creating instances of the classes\n",
    "song1 = Song(title=\"Hukum\", artist=\"Anirudh\", duration=\"3:45\")\n",
    "song2 = Song(title=\"Vathi comming\", artist=\"Anirudh\", duration=\"4:30\")\n",
    "\n",
    "playlist1 = Playlist(name=\"Kutty story\")\n",
    "playlist1.add_song(song1)\n",
    "playlist1.add_song(song2)\n",
    "\n",
    "player = MusicPlayer()\n",
    "player.create_playlist(\"Mix\")\n",
    "player.playlists[0].add_song(song1)  # Adding the same song to another playlist\n",
    "\n",
    "# Playing songs\n",
    "playlist1.play_all()\n",
    "player.playlists[0].play_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Explain the concept of \"has-a\" relationships in composition and how it helps design software systems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In object-oriented programming, a \"has-a\" relationship is a type of association between classes that signifies that one class has another class as a part or component. This relationship is typically implemented through composition, where one class includes an instance of another class as one of its members (attributes). The class containing the instance is said to \"have\" or \"own\" the other class.\n",
    "\n",
    "Here are key points to understand about \"has-a\" relationships in composition and how they contribute to designing software systems:\n",
    "\n",
    "1. **Composition and \"Has-a\" Relationship:**\n",
    "   - **Definition:** Composition is a design principle where a class includes objects of other classes to create more complex objects. The \"has-a\" relationship is a manifestation of composition.\n",
    "   - **Implementation:** The class with the \"has-a\" relationship includes an instance of another class as an attribute.\n",
    "\n",
    "2. **Code Reusability and Modularity:**\n",
    "   - **Benefits:** Composition enhances code reusability and modularity. By composing classes with well-defined responsibilities, you can reuse existing classes in different contexts and easily modify or replace components without affecting the entire system.\n",
    "   - **Example:** For instance, a `Car` class can have a \"has-a\" relationship with an `Engine` class. This allows you to reuse the `Engine` class in various types of cars without duplicating code.\n",
    "\n",
    "3. **Flexibility and Maintainability:**\n",
    "   - **Flexibility:** \"Has-a\" relationships provide flexibility. If the requirements change or new features need to be added, you can modify or extend individual components without affecting the entire system.\n",
    "   - **Example:** In a graphics application, a `Canvas` class might have a \"has-a\" relationship with a `Shape` class. Adding a new shape doesn't require modifying the `Canvas` class, promoting flexibility.\n",
    "\n",
    "4. **Reduced Coupling:**\n",
    "   - **Decoupling:** Composition reduces the coupling between classes compared to deep inheritance hierarchies. Classes can evolve independently, and changes to one class don't necessarily impact the other.\n",
    "   - **Example:** A `House` class might have a \"has-a\" relationship with a `Kitchen` class. Changing the implementation of the `Kitchen` doesn't affect the overall behavior of the `House` class.\n",
    "\n",
    "5. **Encapsulation and Abstraction:**\n",
    "   - **Encapsulation:** \"Has-a\" relationships encapsulate the implementation details of one class within another, promoting information hiding.\n",
    "   - **Abstraction:** It allows for abstraction, where a complex system is represented by higher-level entities (classes) containing lower-level details (other classes).\n",
    "\n",
    "6. **Improved Testing:**\n",
    "   - **Isolation:** Components in a \"has-a\" relationship can be tested in isolation. You can test each class independently, facilitating unit testing and making it easier to identify and fix issues.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Create a Python class for a computer system, using composition to represent components like CPU, RAM, and storage devices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intel CPU processing data at 3.2 GHz\n",
      "Reading data from 8 GB RAM\n",
      "Storing data in 256 GB storage\n"
     ]
    }
   ],
   "source": [
    "class CPU:\n",
    "    def __init__(self, brand, speed):\n",
    "        self.brand = brand\n",
    "        self.speed = speed\n",
    "\n",
    "    def process_data(self):\n",
    "        print(f\"{self.brand} CPU processing data at {self.speed} GHz\")\n",
    "\n",
    "class RAM:\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity\n",
    "\n",
    "    def read_data(self):\n",
    "        print(f\"Reading data from {self.capacity} GB RAM\")\n",
    "\n",
    "class Storage:\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity\n",
    "\n",
    "    def store_data(self):\n",
    "        print(f\"Storing data in {self.capacity} GB storage\")\n",
    "\n",
    "class Computer:\n",
    "    def __init__(self, cpu, ram, storage):\n",
    "        self.cpu = cpu  # Composition: Computer has a CPU\n",
    "        self.ram = ram  # Composition: Computer has RAM\n",
    "        self.storage = storage  # Composition: Computer has Storage\n",
    "\n",
    "    def perform_computations(self):\n",
    "        self.cpu.process_data()\n",
    "        self.ram.read_data()\n",
    "        self.storage.store_data()\n",
    "\n",
    "# Example Usage\n",
    "my_cpu = CPU(brand=\"Intel\", speed=3.2)\n",
    "my_ram = RAM(capacity=8)\n",
    "my_storage = Storage(capacity=256)\n",
    "\n",
    "my_computer = Computer(cpu=my_cpu, ram=my_ram, storage=my_storage)\n",
    "\n",
    "# Perform computations using the computer\n",
    "my_computer.perform_computations()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Describe the concept of \"delegation\" in composition and how it simplifies the design of complex systems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Delegation, in the context of object-oriented programming and composition, is a design pattern where one object assigns or forwards a task to another object. It's a way to achieve code reuse and modularity by allowing one class to utilize the functionality of another class without directly inheriting from it. Delegation simplifies the design of complex systems by promoting flexibility, modularity, and separation of concerns.\n",
    "\n",
    "Here are key aspects of delegation in composition:\n",
    "\n",
    "1. **Responsibility Transfer:**\n",
    "   - **Delegating Tasks:** Delegation involves assigning specific tasks or responsibilities to another object. Instead of implementing the behavior directly, an object delegates the responsibility to another object.\n",
    "\n",
    "2. **Composition-Based Relationship:**\n",
    "   - **Has-a Relationship:** Delegation is often associated with composition, where one class includes an instance of another class. The class with the responsibility retains a reference to the delegate class.\n",
    "\n",
    "3. **Code Reusability:**\n",
    "   - **Promoting Code Reuse:** Delegation enables the reuse of existing classes in new contexts. Instead of inheriting behavior, a class can delegate certain tasks to another class, promoting code reuse and modularity.\n",
    "\n",
    "4. **Flexibility and Adaptability:**\n",
    "   - **Easier Adaptations:** Delegation makes it easier to adapt to changes. If the behavior of the delegate class needs to be modified or replaced, it can be done independently without affecting the delegating class.\n",
    "\n",
    "5. **Encapsulation and Separation of Concerns:**\n",
    "   - **Encapsulation:** Delegation encapsulates the details of how a task is performed within the delegate class. This promotes information hiding and abstraction.\n",
    "   - **Separation of Concerns:** Different concerns are separated into distinct classes, making the codebase more modular and easier to understand.\n",
    "\n",
    "6. **Reduced Code Coupling:**\n",
    "   - **Loose Coupling:** Delegation reduces the coupling between classes. The delegating class depends on the interface of the delegate class rather than its implementation, leading to loose coupling.\n",
    "\n",
    "7. **Example:**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doing office work...\n",
      "Printing document: Report\n"
     ]
    }
   ],
   "source": [
    "class Printer:\n",
    "    def print_document(self, document):\n",
    "        print(f\"Printing document: {document}\")\n",
    "\n",
    "class OfficeWorker:\n",
    "    def __init__(self, printer):\n",
    "        self.printer = printer  # Delegation: OfficeWorker delegates printing to Printer\n",
    "\n",
    "    def do_work(self):\n",
    "        # Perform other office work\n",
    "        print(\"Doing office work...\")\n",
    "        \n",
    "    def print_document(self, document):\n",
    "        self.printer.print_document(document)  # Delegating the printing task\n",
    "\n",
    "# Example Usage\n",
    "my_printer = Printer()\n",
    "my_office_worker = OfficeWorker(printer=my_printer)\n",
    "\n",
    "my_office_worker.do_work()\n",
    "my_office_worker.print_document(\"Report\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Create a Python class for a car, using composition to represent components like the engine, wheels, and transmission."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Engine started\n",
      "Wheels rolling\n",
      "Car started\n",
      "Gear shifted\n",
      "Car is in motion\n",
      "Engine stopped\n",
      "Wheels stopped\n",
      "Car stopped\n"
     ]
    }
   ],
   "source": [
    "class Engine:\n",
    "    def start(self):\n",
    "        print(\"Engine started\")\n",
    "\n",
    "    def stop(self):\n",
    "        print(\"Engine stopped\")\n",
    "\n",
    "class Wheels:\n",
    "    def roll(self):\n",
    "        print(\"Wheels rolling\")\n",
    "\n",
    "    def stop(self):\n",
    "        print(\"Wheels stopped\")\n",
    "\n",
    "class Transmission:\n",
    "    def shift_gear(self):\n",
    "        print(\"Gear shifted\")\n",
    "\n",
    "class Car:\n",
    "    def __init__(self, engine, wheels, transmission):\n",
    "        self.engine = engine  # Composition: Car has an Engine\n",
    "        self.wheels = wheels  # Composition: Car has Wheels\n",
    "        self.transmission = transmission  # Composition: Car has a Transmission\n",
    "\n",
    "    def start(self):\n",
    "        self.engine.start()\n",
    "        self.wheels.roll()\n",
    "        print(\"Car started\")\n",
    "\n",
    "    def stop(self):\n",
    "        self.engine.stop()\n",
    "        self.wheels.stop()\n",
    "        print(\"Car stopped\")\n",
    "\n",
    "    def drive(self):\n",
    "        self.transmission.shift_gear()\n",
    "        print(\"Car is in motion\")\n",
    "\n",
    "# Example Usage\n",
    "my_engine = Engine()\n",
    "my_wheels = Wheels()\n",
    "my_transmission = Transmission()\n",
    "\n",
    "my_car = Car(engine=my_engine, wheels=my_wheels, transmission=my_transmission)\n",
    "\n",
    "# Perform actions using the car\n",
    "my_car.start()\n",
    "my_car.drive()\n",
    "my_car.stop()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. How can you encapsulate and hide the details of composed objects in Python classes to maintain abstraction?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encapsulation is a fundamental principle in object-oriented programming that involves bundling the data (attributes) and methods that operate on the data within a single unit, known as a class. When dealing with composed objects in Python, encapsulation can be used to hide the internal details of the composed objects and maintain abstraction. Here are some strategies to achieve encapsulation and hide details in composed objects:\n",
    "\n",
    "1. **Private Attributes:**\n",
    "   - Use private attributes (attributes with names starting with a double underscore, e.g., `__attribute`) to make the internal details of an object private to the class.\n",
    "   - This prevents direct access to the attributes from outside the class, promoting encapsulation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Car:\n",
    "    def __init__(self, engine, wheels, transmission):\n",
    "        self.__engine = engine  # Private attribute\n",
    "        self.__wheels = wheels  # Private attribute\n",
    "        self.__transmission = transmission  # Private attribute\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "2. **Getter and Setter Methods:**\n",
    "   - Provide getter and setter methods to access and modify the private attributes.\n",
    "   - This allows controlled access to the internal details and enables you to implement additional logic when getting or setting values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    # ... (previous code)\n",
    "\n",
    "    def get_engine(self):\n",
    "        return self.__engine\n",
    "    def set_engine(self, engine):\n",
    "        # Additional logic, if needed\n",
    "        self.__engine = engine\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "3. **Method Abstraction:**\n",
    "   - Define methods that abstract the functionality of the composed objects.\n",
    "   - Expose only high-level methods in the class interface, hiding the specific details of how the composed objects perform their tasks.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Car:\n",
    "    # ... (previous code)\n",
    "\n",
    "    def start(self):\n",
    "        self.__engine.start()\n",
    "        self.__wheels.roll()\n",
    "        print(\"Car started\")\n",
    "\n",
    "    def stop(self):\n",
    "        self.__engine.stop()\n",
    "        self.__wheels.stop()\n",
    "        print(\"Car stopped\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. **Use of Properties:**\n",
    "   - Use the `@property` decorator to create read-only properties for certain attributes.\n",
    "   - This allows controlled access to the attribute while preventing direct modification.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Car:\n",
    "    def __init__(self, engine, wheels, transmission):\n",
    "        self.__engine = engine  # Private attribute\n",
    "        self.__wheels = wheels  # Private attribute\n",
    "        self.__transmission = transmission  # Private attribute\n",
    "\n",
    "    @property\n",
    "    def engine(self):\n",
    "        return self.__engine\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12. Create a Python class for a university course, using composition to represent students, instructors, and course materials."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Course Code: CS101\n",
      "Course Name: Python Programming\n",
      "\n",
      "Instructor Information:\n",
      "Instructor ID: I001\n",
      "Name: Dr. Kali\n",
      "\n",
      "Student Information:\n",
      "Student ID: S001\n",
      "Name: Tony\n",
      "Student ID: S002\n",
      "Name: Bruce\n",
      "\n",
      "Course Material Information:\n",
      "Course Material: Introduction to Python\n",
      "Content: Basic Python programming concepts.\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, student_id, name):\n",
    "        self.student_id = student_id\n",
    "        self.name = name\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Student ID: {self.student_id}\")\n",
    "        print(f\"Name: {self.name}\")\n",
    "\n",
    "class Instructor:\n",
    "    def __init__(self, instructor_id, name):\n",
    "        self.instructor_id = instructor_id\n",
    "        self.name = name\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Instructor ID: {self.instructor_id}\")\n",
    "        print(f\"Name: {self.name}\")\n",
    "\n",
    "class CourseMaterial:\n",
    "    def __init__(self, title, content):\n",
    "        self.title = title\n",
    "        self.content = content\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Course Material: {self.title}\")\n",
    "        print(f\"Content: {self.content}\")\n",
    "\n",
    "class UniversityCourse:\n",
    "    def __init__(self, course_code, course_name, instructor, students, course_material):\n",
    "        self.course_code = course_code\n",
    "        self.course_name = course_name\n",
    "        self.instructor = instructor  # Composition: UniversityCourse has an Instructor\n",
    "        self.students = students  # Composition: UniversityCourse has a list of Students\n",
    "        self.course_material = course_material  # Composition: UniversityCourse has CourseMaterial\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Course Code: {self.course_code}\")\n",
    "        print(f\"Course Name: {self.course_name}\")\n",
    "        print(\"\\nInstructor Information:\")\n",
    "        self.instructor.display_info()\n",
    "        print(\"\\nStudent Information:\")\n",
    "        for student in self.students:\n",
    "            student.display_info()\n",
    "        print(\"\\nCourse Material Information:\")\n",
    "        self.course_material.display_info()\n",
    "\n",
    "# Example Usage\n",
    "student1 = Student(student_id=\"S001\", name=\"Tony\")\n",
    "student2 = Student(student_id=\"S002\", name=\"Bruce\")\n",
    "\n",
    "instructor = Instructor(instructor_id=\"I001\", name=\"Dr. Kali\")\n",
    "\n",
    "course_material = CourseMaterial(title=\"Introduction to Python\", content=\"Basic Python programming concepts.\")\n",
    "\n",
    "students_list = [student1, student2]\n",
    "\n",
    "python_course = UniversityCourse(course_code=\"CS101\", course_name=\"Python Programming\", instructor=instructor, students=students_list, course_material=course_material)\n",
    "\n",
    "# Display information about the Python course\n",
    "python_course.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13. Discuss the challenges and drawbacks of composition, such as increased complexity and potential for tight coupling between objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While composition is a powerful design concept in object-oriented programming, it is not without its challenges and drawbacks. Here are some potential issues associated with composition:\n",
    "\n",
    "1. **Increased Complexity:**\n",
    "   - **Challenge:** As a system grows and more components are composed together, managing the interactions between these components can become complex.\n",
    "   - **Drawback:** The overall complexity of the system may increase, making it more challenging to understand, maintain, and extend.\n",
    "\n",
    "2. **Tight Coupling:**\n",
    "   - **Challenge:** Composition can lead to tight coupling between objects if the interactions between components are not carefully managed.\n",
    "   - **Drawback:** Tight coupling makes it harder to modify or replace individual components without affecting other parts of the system. It can hinder code flexibility and reusability.\n",
    "\n",
    "3. **Inheritance vs. Composition Dilemma:**\n",
    "   - **Challenge:** Deciding whether to use composition or inheritance can be challenging, and there is often a trade-off between the two.\n",
    "   - **Drawback:** In some cases, choosing composition over inheritance might result in more code that needs to be written and maintained.\n",
    "\n",
    "4. **Abstraction Levels:**\n",
    "   - **Challenge:** Achieving the right level of abstraction can be challenging. It's important to strike a balance between encapsulating details and providing a useful and intuitive interface.\n",
    "   - **Drawback:** Poorly chosen abstractions may lead to a leaky abstraction, where internal details are exposed unintentionally.\n",
    "\n",
    "5. **Performance Overhead:**\n",
    "   - **Challenge:** There can be a slight performance overhead associated with composition, especially if there are many small objects being composed together.\n",
    "   - **Drawback:** In performance-critical systems, this overhead might be a concern, although it is often negligible in most applications.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 14. Create a Python class hierarchy for a restaurant system, using composition to represent menus, dishes, and ingredients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restaurant: Italian Delight\n",
      "Menus:\n",
      "Menu: Pizza Menu\n",
      "Dishes:\n",
      "Dish: Margherita Pizza\n",
      "Ingredients:\n",
      "Ingredient: Tomato\n",
      "Ingredient: Cheese\n",
      "Ingredient: Dough\n",
      "Menu: Pasta Menu\n",
      "Dishes:\n",
      "Dish: Spaghetti Bolognese\n",
      "Ingredients:\n",
      "Ingredient: Tomato\n",
      "Ingredient: Cheese\n"
     ]
    }
   ],
   "source": [
    "class Ingredient:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Ingredient: {self.name}\")\n",
    "\n",
    "class Dish:\n",
    "    def __init__(self, name, ingredients):\n",
    "        self.name = name\n",
    "        self.ingredients = ingredients  # Composition: Dish has a list of Ingredients\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Dish: {self.name}\")\n",
    "        print(\"Ingredients:\")\n",
    "        for ingredient in self.ingredients:\n",
    "            ingredient.display_info()\n",
    "\n",
    "class Menu:\n",
    "    def __init__(self, name, dishes):\n",
    "        self.name = name\n",
    "        self.dishes = dishes  # Composition: Menu has a list of Dishes\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Menu: {self.name}\")\n",
    "        print(\"Dishes:\")\n",
    "        for dish in self.dishes:\n",
    "            dish.display_info()\n",
    "\n",
    "class Restaurant:\n",
    "    def __init__(self, name, menus):\n",
    "        self.name = name\n",
    "        self.menus = menus  # Composition: Restaurant has a list of Menus\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Restaurant: {self.name}\")\n",
    "        print(\"Menus:\")\n",
    "        for menu in self.menus:\n",
    "            menu.display_info()\n",
    "\n",
    "# Example Usage\n",
    "ingredient1 = Ingredient(name=\"Tomato\")\n",
    "ingredient2 = Ingredient(name=\"Cheese\")\n",
    "ingredient3 = Ingredient(name=\"Dough\")\n",
    "\n",
    "dish1 = Dish(name=\"Margherita Pizza\", ingredients=[ingredient1, ingredient2, ingredient3])\n",
    "dish2 = Dish(name=\"Spaghetti Bolognese\", ingredients=[ingredient1, ingredient2])\n",
    "\n",
    "menu1 = Menu(name=\"Pizza Menu\", dishes=[dish1])\n",
    "menu2 = Menu(name=\"Pasta Menu\", dishes=[dish2])\n",
    "\n",
    "restaurant = Restaurant(name=\"Italian Delight\", menus=[menu1, menu2])\n",
    "\n",
    "# Display information about the restaurant\n",
    "restaurant.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15. Explain how composition enhances code maintainability and modularity in Python programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Composition enhances code maintainability and modularity in Python programs by promoting a design approach that encourages the separation of concerns, reusability of code, and flexibility in making changes. Here are several ways in which composition contributes to these benefits:\n",
    "\n",
    "1. **Separation of Concerns:**\n",
    "   - **Definition:** Composition allows you to break down a system into smaller, more manageable components.\n",
    "   - **Advantage:** Each component is responsible for a specific aspect of functionality, promoting a clear separation of concerns. This makes it easier to understand and reason about individual parts of the system.\n",
    "\n",
    "2. **Code Reusability:**\n",
    "   - **Definition:** With composition, you can create reusable components that encapsulate specific functionality.\n",
    "   - **Advantage:** These components can be used in different contexts and scenarios, reducing the need to duplicate code. Reusable components contribute to a more maintainable and scalable codebase.\n",
    "\n",
    "3. **Flexibility and Adaptability:**\n",
    "   - **Definition:** Composition allows you to assemble systems from smaller, interchangeable components.\n",
    "   - **Advantage:** If requirements change or new features need to be added, you can modify or replace individual components without affecting the entire system. This flexibility is crucial for adapting to evolving project needs.\n",
    "\n",
    "4. **Encapsulation:**\n",
    "   - **Definition:** Composition promotes encapsulation by hiding the internal details of a component.\n",
    "   - **Advantage:** Components expose a well-defined interface while hiding implementation details. This encapsulation protects the internal workings of a component, allowing changes to be made internally without affecting external code.\n",
    "\n",
    "5. **Modularity:**\n",
    "   - **Definition:** Composition enables the creation of modular systems, where each module (component) represents a self-contained unit of functionality.\n",
    "   - **Advantage:** Modules can be developed, tested, and maintained independently, simplifying the overall development process. Modularity also makes it easier to reason about and test specific parts of the codebase.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 16. Create a Python class for a computer game character, using composition to represent attributes like weapons, armor, and inventory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Character: Hero, Health: 100\n",
      "Equipped Weapon:\n",
      "Weapon: Sword, Damage: 20\n",
      "Equipped Armor:\n",
      "Armor: Shield, Defense: 10\n",
      "Inventory:\n",
      "Item: Health Potion, Quantity: 3\n"
     ]
    }
   ],
   "source": [
    "class Weapon:\n",
    "    def __init__(self, name, damage):\n",
    "        self.name = name\n",
    "        self.damage = damage\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Weapon: {self.name}, Damage: {self.damage}\")\n",
    "\n",
    "class Armor:\n",
    "    def __init__(self, name, defense):\n",
    "        self.name = name\n",
    "        self.defense = defense\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Armor: {self.name}, Defense: {self.defense}\")\n",
    "\n",
    "class InventoryItem:\n",
    "    def __init__(self, name, quantity):\n",
    "        self.name = name\n",
    "        self.quantity = quantity\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Item: {self.name}, Quantity: {self.quantity}\")\n",
    "\n",
    "class GameCharacter:\n",
    "    def __init__(self, name, health, weapon=None, armor=None, inventory=None):\n",
    "        self.name = name\n",
    "        self.health = health\n",
    "        self.weapon = weapon  # Composition: GameCharacter has a Weapon\n",
    "        self.armor = armor  # Composition: GameCharacter has Armor\n",
    "        self.inventory = inventory if inventory else []  # Composition: GameCharacter has a list of InventoryItems\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Character: {self.name}, Health: {self.health}\")\n",
    "        if self.weapon:\n",
    "            print(\"Equipped Weapon:\")\n",
    "            self.weapon.display_info()\n",
    "        if self.armor:\n",
    "            print(\"Equipped Armor:\")\n",
    "            self.armor.display_info()\n",
    "        if self.inventory:\n",
    "            print(\"Inventory:\")\n",
    "            for item in self.inventory:\n",
    "                item.display_info()\n",
    "\n",
    "# Example Usage\n",
    "sword = Weapon(name=\"Sword\", damage=20)\n",
    "shield = Armor(name=\"Shield\", defense=10)\n",
    "potion = InventoryItem(name=\"Health Potion\", quantity=3)\n",
    "\n",
    "hero = GameCharacter(name=\"Hero\", health=100, weapon=sword, armor=shield, inventory=[potion])\n",
    "\n",
    "# Display information about the game character\n",
    "hero.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 17. Describe the concept of \"aggregation\" in composition and how it differs from simple composition.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aggregation is a concept in object-oriented programming that represents a \"has-a\" relationship between two classes, similar to composition. However, aggregation differs from simple composition in terms of the relationship's strength, lifecycle, and ownership. Aggregation implies a looser relationship where one class contains another, but the contained object can exist independently of the container.\n",
    "\n",
    "Here are the key points that distinguish aggregation from simple composition:\n",
    "\n",
    "1. **Association Strength:**\n",
    "   - **Composition:** In composition, the contained object is a part of the composite object. The contained object's existence is tightly coupled with the composite object, and it typically has no independent lifecycle.\n",
    "   - **Aggregation:** In aggregation, the contained object is associated with the composite object, but it can exist independently. The relationship is more relaxed, and the contained object has its own lifecycle.\n",
    "\n",
    "2. **Ownership and Responsibility:**\n",
    "   - **Composition:** In composition, the composite object (container) owns and is responsible for the creation and destruction of the contained object. The contained object is a part or component of the composite object.\n",
    "   - **Aggregation:** In aggregation, the contained object may have its own lifecycle and is not owned by the composite object. The composite object may reference the contained object, but it doesn't control its creation, destruction, or lifecycle.\n",
    "\n",
    "3. **Multiplicity:**\n",
    "   - **Composition:** In composition, there is a strong multiplicity relationship between the container and the contained object. The contained object is typically a single instance associated with the container.\n",
    "   - **Aggregation:** In aggregation, the multiplicity is more flexible. There can be one-to-one, one-to-many, or many-to-many relationships between the container and the contained object. The contained object may be shared among multiple containers.\n",
    "\n",
    "4. **Navigation:**\n",
    "   - **Composition:** The contained object is usually accessed through the composite object. Navigation from the container to the contained object is straightforward.\n",
    "   - **Aggregation:** While the container may provide access to the contained object, there is a greater possibility that the contained object can be accessed independently.\n",
    "\n",
    "5. **Example:**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Composition Example\n",
    "class Engine:\n",
    "    pass\n",
    "\n",
    "class Car:\n",
    "    def __init__(self):\n",
    "        self.engine = Engine()  # Composition: Car owns the Engine\n",
    "\n",
    "# Aggregation Example\n",
    "class Department:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "class University:\n",
    "    def __init__(self):\n",
    "        self.departments = []  # Aggregation: University references Department objects\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 18. Create a Python class for a house, using composition to represent rooms, furniture, and appliances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "House Information:\n",
      "Room: Kitchen\n",
      "Appliances:\n",
      "Appliance: TV\n",
      "Room: Living Room\n",
      "Furniture:\n",
      "Furniture: Sofa\n"
     ]
    }
   ],
   "source": [
    "class Furniture:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Furniture: {self.name}\")\n",
    "\n",
    "class Appliance:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Appliance: {self.name}\")\n",
    "\n",
    "class Room:\n",
    "    def __init__(self, name, furniture=None, appliances=None):\n",
    "        self.name = name\n",
    "        self.furniture = furniture if furniture else []  # Composition: Room has a list of Furniture\n",
    "        self.appliances = appliances if appliances else []  # Composition: Room has a list of Appliances\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Room: {self.name}\")\n",
    "        if self.furniture:\n",
    "            print(\"Furniture:\")\n",
    "            for item in self.furniture:\n",
    "                item.display_info()\n",
    "        if self.appliances:\n",
    "            print(\"Appliances:\")\n",
    "            for item in self.appliances:\n",
    "                item.display_info()\n",
    "\n",
    "class House:\n",
    "    def __init__(self, rooms):\n",
    "        self.rooms = rooms  # Composition: House has a list of Rooms\n",
    "\n",
    "    def display_info(self):\n",
    "        print(\"House Information:\")\n",
    "        for room in self.rooms:\n",
    "            room.display_info()\n",
    "\n",
    "# Example Usage\n",
    "sofa = Furniture(name=\"Sofa\")\n",
    "tv = Appliance(name=\"TV\")\n",
    "\n",
    "kitchen = Room(name=\"Kitchen\", appliances=[tv])\n",
    "living_room = Room(name=\"Living Room\", furniture=[sofa])\n",
    "\n",
    "my_house = House(rooms=[kitchen, living_room])\n",
    "\n",
    "# Display information about the house\n",
    "my_house.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 19. How can you achieve flexibility in composed objects by allowing them to be replaced or modified dynamically at runtime?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Achieving flexibility in composed objects by allowing them to be replaced or modified dynamically at runtime is crucial for adapting to changing requirements or scenarios. Several design patterns and techniques can be employed to achieve this flexibility:\n",
    "\n",
    "1. **Interface-Based Design:**\n",
    "   - Define interfaces or abstract classes that represent the common behavior expected from composed objects.\n",
    "   - Composed objects can implement these interfaces, allowing them to be replaced dynamically as long as they adhere to the specified interface.\n",
    "\n",
    "2. **Dependency Injection:**\n",
    "   - Inject dependencies into an object rather than creating them internally.\n",
    "   - By injecting dependencies, you can replace or modify components at runtime without modifying the code of the object using them.\n",
    "\n",
    "3. **Factory Pattern:**\n",
    "   - Use a factory pattern to create instances of composed objects.\n",
    "   - The factory can create different implementations of composed objects based on specific criteria or configuration.\n",
    "\n",
    "\n",
    "4. **Decorator Pattern:**\n",
    "   - Use the decorator pattern to dynamically add or replace behavior of composed objects.\n",
    "   - Decorators are classes that wrap other classes, allowing you to modify their behavior.\n",
    "\n",
    " \n",
    "\n",
    "5. **Configuration or Settings:**\n",
    "   - Use configuration files or settings to determine the behavior of composed objects.\n",
    "   - This allows for runtime configuration changes without modifying the code.\n",
    "\n",
    "\n",
    "6. **Strategy Pattern:**\n",
    "   - Use the strategy pattern to encapsulate interchangeable algorithms or behaviors.\n",
    "   - Composed objects can switch between different strategies dynamically.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 20. Create a Python class for a social media application, using composition to represent users, posts, and comments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User: Tony\n",
      "Posts:\n",
      "Tony's Post:\n",
      "Hello, this is my first post!\n",
      "Comments:\n",
      "Ron: Welcome, Tony!\n",
      "User: Ron\n",
      "Posts:\n",
      "Ron's Post:\n",
      "Just joined the social media world!\n",
      "Comments:\n",
      "Tony: Thanks, Ron!\n"
     ]
    }
   ],
   "source": [
    "class Comment:\n",
    "    def __init__(self, user, text):\n",
    "        self.user = user  # Composition: Comment has a User\n",
    "        self.text = text\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"{self.user.username}: {self.text}\")\n",
    "\n",
    "class Post:\n",
    "    def __init__(self, user, content):\n",
    "        self.user = user  # Composition: Post has a User\n",
    "        self.content = content\n",
    "        self.comments = []  # Composition: Post has a list of Comments\n",
    "\n",
    "    def add_comment(self, user, text):\n",
    "        comment = Comment(user=user, text=text)\n",
    "        self.comments.append(comment)\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"{self.user.username}'s Post:\")\n",
    "        print(self.content)\n",
    "        print(\"Comments:\")\n",
    "        for comment in self.comments:\n",
    "            comment.display_info()\n",
    "\n",
    "class User:\n",
    "    def __init__(self, username):\n",
    "        self.username = username\n",
    "        self.posts = []  # Composition: User has a list of Posts\n",
    "\n",
    "    def create_post(self, content):\n",
    "        post = Post(user=self, content=content)\n",
    "        self.posts.append(post)\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"User: {self.username}\")\n",
    "        print(\"Posts:\")\n",
    "        for post in self.posts:\n",
    "            post.display_info()\n",
    "\n",
    "# Example Usage\n",
    "user1 = User(username=\"Tony\")\n",
    "user2 = User(username=\"Ron\")\n",
    "\n",
    "user1.create_post(content=\"Hello, this is my first post!\")\n",
    "user2.create_post(content=\"Just joined the social media world!\")\n",
    "\n",
    "user1.posts[0].add_comment(user=user2, text=\"Welcome, Tony!\")\n",
    "user2.posts[0].add_comment(user=user1, text=\"Thanks, Ron!\")\n",
    "\n",
    "# Display information about the users and their posts\n",
    "user1.display_info()\n",
    "user2.display_info()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}