15_Oct_OOPS2_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ce87d798",
   "metadata": {},
   "source": [
    "# Constructor:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d90b3d28",
   "metadata": {},
   "source": [
    "##### 1. What is a constructor in Python? Explain its purpose and usage.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "8ee39f29",
   "metadata": {},
   "source": [
    "-> In python, A constructor is a special method that is autometically called when you create a instance of a class\n",
    "-> The primary purpose of a constructor is to initialize the attributes of the object being created.\n",
    "-> constructors are definded using the '__init__' method, whcih is a reserved method name in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "10bf8763",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, parameter1, parameter2):\n",
    "        self.attribute1 = parameter1\n",
    "        self.attribute2 = parameter2\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "e98b2f48",
   "metadata": {},
   "source": [
    "-> in this example __init__ is the cunstructor method for the myclass class. it takes self as its first parameter, which is to the instance being created, and two additional parameters, parameter1 and parameter2, which are used to initialize the attributes 'Attribute1' and 'Attribute2'"
   ]
  },
  {
   "cell_type": "raw",
   "id": "889fe631",
   "metadata": {},
   "source": [
    "-> Constructor are essential for setting up the initial state of an object for performing any necesary setup or configuration when an object is created\n",
    "-> They help ensure the object are in a valid and consistent state when they are first instantiated."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0dd1d5d",
   "metadata": {},
   "source": [
    "#### 2. Differentiate between a parameterless constructor and a parameterized constructor in Python.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2c12622d",
   "metadata": {},
   "source": [
    "1) Parameterless Constructor:\n",
    "-> A parameterless constructor is also known as a defeault constructor or no argument constructor\n",
    "-> it is defined with the __init__ method but is does not accept any additional parameters other than the mandatory self parameter\n",
    "-> its primary purpose is to set up initial attribute values or perform any other necessary setup when an object is created\n",
    "-> parameterless constructor can be used to provide default values for the attributes\n",
    "\n",
    "Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8189d4f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.attribute1 = None\n",
    "        self.attribute2 = None\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2578e4eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_instance = MyClass()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "a5d01ef5",
   "metadata": {},
   "source": [
    "2) Parameterized Constructor\n",
    "-> A parameterized constructor, also known as an argument constructor, accepts additional parameters in addition the self parameter\n",
    "-> it is defined with the __init__ method and these parameters are used to initialize the attribute of the object \n",
    "-> the primary purpose is to allow customization of object \n",
    "-> initialization by passing specific value during object creation\n",
    "\n",
    "Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "275e2658",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, parameter1, parameter2):\n",
    "        self.attribute1 = parameter1\n",
    "        self.attribute2 = parameter2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7eb9eac8",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_instance = MyClass(\"value1\", \"value2\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dce3fb4",
   "metadata": {},
   "source": [
    "#### 3. How do you define a constructor in a Python class? Provide an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "db77862a",
   "metadata": {},
   "source": [
    "-> In python, You define a consturctor in a class using the __init__ method.\n",
    "-> __init__ is special method that is autometically called when you create an instance of the class.\n",
    "-> it is responisble for initializing the attributes of the object\n",
    "\n",
    "example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "870edb25",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, parameter1, parameter2):\n",
    "        self.attribute1 = parameter1\n",
    "        self.attribute2 = parameter2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e0a8947",
   "metadata": {},
   "source": [
    "#### 4. Explain the `__init__` method in Python and its role in constructors.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "1fcfc4ae",
   "metadata": {},
   "source": [
    "-> init method is a special method used to define constructors in a class.\n",
    "-> Constructors are responsible for initializing the attributes of an object when an instance of the class is created\n",
    "-> it plays a vital role in constructors within classes\n",
    "-> the name init stands for initialize.\n",
    "-> when you create an instance of a class the __init__ methods is autometically called. \n",
    "-> it is where you can define the initialization behavior for the object by setting up its attributes or performing any necessary setup."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a0996c2",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "88f4c74b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class person:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    def access_name_age(self):\n",
    "        return self.name + ' ' + self.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "dead0452",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mit\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "P1 = person('Mit',21)\n",
    "\n",
    "print(P1.name)\n",
    "print(P1.age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83ac1e81",
   "metadata": {},
   "source": [
    "#### 6. How can you call a constructor explicitly in Python? Give an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "75dfb3dc",
   "metadata": {},
   "source": [
    "-> there is no way we can call constructor explicitly \n",
    "-> Constructors are autometically invoked when you create an instance of a class using the class name followed by parentheses.\n",
    "-> however, you can indirectly call a consturctor explicitly by creating a new instance of the calss\n",
    "-> if you want to reinitialize an object with new values or perform some specific actions after the object has alreeady been created, you can define additional method within the class and call those methods explicitly\n",
    "\n",
    "example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d07f8606",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New Value\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, parameter):\n",
    "        self.attribute = parameter\n",
    "\n",
    "    def update_attribute(self, new_value):\n",
    "        self.attribute = new_value\n",
    "\n",
    "# Creating an instance of MyClass\n",
    "my_instance = MyClass(\"Hello, World!\")\n",
    "\n",
    "# Explicitly calling the update_attribute method to change the attribute\n",
    "my_instance.update_attribute(\"New Value\")\n",
    "\n",
    "# Accessing the updated attribute\n",
    "print(my_instance.attribute)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8579688a",
   "metadata": {},
   "source": [
    "#### 7. What is the significance of the `self` parameter in Python constructors? Explain with an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "bb234269",
   "metadata": {},
   "source": [
    "-> the self parameter in Python constructors and method plays cruial role in OOPs.\n",
    "-> it represents the instance of the class, allowing you to access and manipulate its attributes and methods\n",
    "-> without self you wouldn't have a way to distinguish between class level variables and instance level variables or to interact with the specific instance for which a method is called"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "aed5fadd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class person:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    def access_name_age(self):\n",
    "        return (self.name, self.age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3148eb3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mit', 21)\n"
     ]
    }
   ],
   "source": [
    "P1 = person('Mit',21)\n",
    "\n",
    "print(P1.access_name_age())"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4d8d4eff",
   "metadata": {},
   "source": [
    "-> in this example self parameter is used within the consturctor to assign the name and age attribute to specific instance P1 \n",
    "-> the access_name_age method also uses self to access the name and age attribute of the respective instance when generating the introduction\n",
    "\n",
    "\n",
    "-> Because of self, each instance has its own set of attributes and the access name age method correctly identifies the attributes associated with the instance it's called on\n",
    "\n",
    "-> this encapsulation and instance-specific  data are essential aspecrs of object oriented programming in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04afe03f",
   "metadata": {},
   "source": [
    "#### 8. Discuss the concept of default constructors in Python. When are they used?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f10a885b",
   "metadata": {},
   "source": [
    "-> In python, default constructors, also known as parameterless constructors or no argument constructors refer to constructors tghat do not accept any additional parameters other than mandatory self parmeter.\n",
    "\n",
    "-> They are implicitly created if you don't define a constructor with init method in your class\n",
    "\n",
    "-> Default constructors are used to initialize the attributes of an object with default values or to perform any other necessary setup when an object is created\n",
    "\n",
    "example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "523aa951",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.attribute1 = \"default_value_1\"\n",
    "        self.attribute2 = \"default_value_2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d1918b0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "default_value_1\n",
      "default_value_2\n"
     ]
    }
   ],
   "source": [
    "my_instance = MyClass()\n",
    "\n",
    "print(my_instance.attribute1)  # Output: default_value_1\n",
    "print(my_instance.attribute2)  # Output: default_value_2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38524d99",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "92e1d7cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle: \n",
    "    def __init__(self, Width, Length):\n",
    "        self.Width = Width\n",
    "        self.Length = Length\n",
    "        \n",
    "    def Area_of_Rectangle(self):\n",
    "        return self.Length*self.Width\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "af881cf5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "156"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AOR = Rectangle(12,13)\n",
    "\n",
    "AOR.Area_of_Rectangle()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e29afe41",
   "metadata": {},
   "source": [
    "#### 10. How can you have multiple constructors in a Python class? Explain with an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "005608c4",
   "metadata": {},
   "source": [
    "-> Python does not support explicit multiple constructors, yet there are some ways using which multiple constructors can be achieved. if multiple init methods are written for the same class, then the latest one overwrites all the previous constructors and the reason for this can be, python store all the function names in a class as in a dictionary so, when a new function is defined with the same name, the key remains the same but the value gets overridden by the new function body.\n",
    "\n",
    "However, we can simulate multiple consturctors by using default values or using class methods to create similar behavior based on different parameters. \n",
    "\n",
    "example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "8d1846e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, parameter1=None, parameter2=None):\n",
    "        if parameter1 is None and parameter2 is None:\n",
    "            # Default constructor behavior\n",
    "            self.attribute1 = 0\n",
    "            self.attribute2 = 0\n",
    "        else:\n",
    "            self.attribute1 = parameter1\n",
    "            self.attribute2 = parameter2\n",
    "\n",
    "# Creating instances using different parameter combinations\n",
    "instance1 = MyClass()  # Uses default values\n",
    "instance2 = MyClass(5)  # Sets parameter1, defaults parameter2\n",
    "instance3 = MyClass(10, 20)  # Sets both parameters\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "152ac69f",
   "metadata": {},
   "source": [
    "#### 11. What is method overloading, and how is it related to constructors in Python?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "abdd8d86",
   "metadata": {},
   "source": [
    "-> Method overloading is a concept in programming language that allows a class to have multople method with same name but with different parameters\n",
    "-> in other words, you can define multiple methods in a class with the same name but a different number of type of parameters\n",
    "-> the complier or interpreter determines which method to call based on the number and types which method to call based on the number and types of arguments provided during the function or method call.\n",
    "\n",
    "-> Howevever, it's importaant to note that python does not support tradiaitonal method overloading like other languages\n",
    "-> in python, if you define multiple methods with the same name in a class, the last one defined will override any previous ones, and only the last one will be used.\n",
    "\n",
    "-> Python supports a form of method overloading through default argument values and variable-length arguments lists. this allows a single method to be defined with different sets of parameters, providing a level of flexibility similar to traditional method overloading.\n",
    "\n",
    "-> Now, relating this to constructors in python, constructors are a special types of method in a class used to initializing objects, python does not support multiple constructors in traditional sense\n",
    "\n",
    "-> however to achiever constructor like behavior using default values for parameters or by using class methods.\n",
    "\n",
    "example "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "052134e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 0\n",
      "20 30\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, param1, param2=0):\n",
    "        self.param1 = param1\n",
    "        self.param2 = param2\n",
    "\n",
    "# Creating objects with different parameter sets\n",
    "obj1 = MyClass(10)\n",
    "obj2 = MyClass(20, 30)\n",
    "\n",
    "print(obj1.param1, obj1.param2)  # Output: 10 0\n",
    "print(obj2.param1, obj2.param2)  # Output: 20 30\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aac79f0",
   "metadata": {},
   "source": [
    "#### 12. Explain the use of the `super()` function in Python constructors. Provide an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "296b435c",
   "metadata": {},
   "source": [
    "-> in Python, the super() function is used to call a method from a parent class. including constructors.\n",
    "-> it's often used in the __init__ method of a derived class to invoke the constructor of the parent class.\n",
    "-> this ensures that the initialization code in the parent class is excecuted before the derived class add or modifies behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "95ad49b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parent constructor called with name: John\n",
      "Child constructor called with age: 10\n"
     ]
    }
   ],
   "source": [
    "class Parent:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        print(f\"Parent constructor called with name: {self.name}\")\n",
    "\n",
    "class Child(Parent):\n",
    "    def __init__(self, name, age):\n",
    "        super().__init__(name)  # Call the constructor of the parent class\n",
    "        self.age = age\n",
    "        print(f\"Child constructor called with age: {self.age}\")\n",
    "\n",
    "# Create an instance of the Child class\n",
    "child_obj = Child(\"John\", 10)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2abc419",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ac2a2d4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Title: The Catcher in the Rye\n",
      "Author: J.D. Salinger\n",
      "Published Year: 1951\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author, published_year):\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "        self.published_year = published_year\n",
    "\n",
    "    def display_details(self):\n",
    "        print(f\"Title: {self.title}\")\n",
    "        print(f\"Author: {self.author}\")\n",
    "        print(f\"Published Year: {self.published_year}\")\n",
    "\n",
    "# Creating an instance of the Book class\n",
    "book1 = Book(\"The Catcher in the Rye\", \"J.D. Salinger\", 1951)\n",
    "\n",
    "# Displaying book details\n",
    "book1.display_details()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6942b064",
   "metadata": {},
   "source": [
    "#### 14. Discuss the differences between constructors and regular methods in Python classes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ea518e3",
   "metadata": {},
   "source": [
    "In Python classes, custructors and regular methods serve different purposes and have distinct characteristics.\n",
    "\n",
    "1) Initialization Vs General Behavior:\n",
    "-> Constructor is a special method in class that automatically called when an object of class is created. It is primarily used for initializing the attributes of the object.\n",
    "-> regular methods are used for defining the general behavior of an object. They can perform various actions or computations but are not specificlly tied to the object's creation\n",
    "\n",
    "\n",
    "2) Name:\n",
    "-> The constructor method is named __init__ in python. it is invoked automatically when an object is instantiated \n",
    "-> regular method can have nay name that follows the rules for naming function in python \n",
    "\n",
    "3) Invocation:\n",
    "-> The constructor is invoked automatically when an object is created using the class. It initializes the attributes of the object\n",
    "-> Regular methods are called explicitly by the object or class. They are invoked when you want to perform a specific action associated with the object\n",
    "\n",
    "4) Return Value:\n",
    "-> The __init++ constructor does not have an explicit return statement. it initializes the object's attributes but does not return a value\n",
    "-> Regular method can have reutrn statement to provide a result or perform an action with side effects \n",
    "\n",
    "5) use of self:\n",
    "-> The first parameter of a constructor is self, which represents the instance of the class being created. It is used to refer to the instance's attirbutes within the constructor\n",
    "-> regular method also take self as the first parameter allowing them to access and modify object's attributes.\n",
    "\n",
    "\n",
    "example "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5ac57968",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example\n",
      "Regular method called with attribute: example\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, attribute):\n",
    "        self.attribute = attribute\n",
    "\n",
    "    def regular_method(self):\n",
    "        print(f\"Regular method called with attribute: {self.attribute}\")\n",
    "\n",
    "# Creating an instance of the class\n",
    "obj = MyClass(\"example\")\n",
    "\n",
    "# Constructor is automatically called during object creation\n",
    "# It initializes the 'attribute' attribute\n",
    "print(obj.attribute)  # Output: example\n",
    "\n",
    "# Calling a regular method explicitly\n",
    "obj.regular_method()  # Output: Regular method called with attribute: example\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "008f26ea",
   "metadata": {},
   "source": [
    "#### 15. Explain the role of the `self` parameter in instance variable initialization within a constructor.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5a83c901",
   "metadata": {},
   "source": [
    "-> the self parameter in Python plays a crucial role in instance variable initialization within a constructor \n",
    "-> In the context of a class and its constructor, self is a reference to the instance of the class that is being created \n",
    "-> it allows you to access and manipulate instance variable variables and other attributes speciific to that instance \n",
    "\n",
    "-> Self in context of constructor \n",
    "\n",
    "1) Reference to the instance \n",
    "-> When a class is instantiated, the self parameter refers to the instance of that class, it distinguishes instance variable from local variables within the class\n",
    "\n",
    "2) Instance Variable Initialization \n",
    "-> In a constructor, which is typically named __init__ in python, self is used to initialize instance variables. Instance variables are attributes that belong to a specific instance of the class\n",
    "\n",
    "3) Accessing instance variables: \n",
    "-> Throughout the class methods, including the constructor, you use self to access and modify instance variables. \n",
    "-> This ensures that you are working with the attributes of the specific instance, not with local variables or attributes of other instances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "824ea82c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: John, Age: 25\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}, Age: {self.age}\")\n",
    "\n",
    "# Creating an instance of the class\n",
    "obj = MyClass(\"John\", 25)\n",
    "\n",
    "# Accessing and displaying instance variables using 'self'\n",
    "obj.display_info()  # Output: Name: John, Age: 25\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "a649a0f6",
   "metadata": {},
   "source": [
    "-> The use of self ensures that the instance variables are associated with the particular instance of the class, allowing for proper encapsulation and avoiding naming conflicts between instances"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9405267",
   "metadata": {},
   "source": [
    "#### 16. How do you prevent a class from having multiple instances by using constructors in Python? Provide an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "1bc09e15",
   "metadata": {},
   "source": [
    "-> to prevent class from having multiple instance in Python, you can implement the singleton pattern\n",
    "-> The singleton pattern ensures that a class has only one instance and provide a global point of access to that instance, \n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a87dab46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Instance\n",
      "Second Instance\n",
      "Second Instance\n"
     ]
    }
   ],
   "source": [
    "class SingletonClass:\n",
    "    _instance = None \n",
    "    \n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        if not cls._instance:\n",
    "            cls._instance = super().__new__(cls)\n",
    "        return cls._instance\n",
    "    \n",
    "    def __init__(self, data):\n",
    "        if not hasattr(self,'Initialized'):\n",
    "            self.data = data\n",
    "            self.initialized = True\n",
    "            \n",
    "# Creating instances\n",
    "singleton_instance1 = SingletonClass(\"First Instance\")\n",
    "print(singleton_instance1.data)  # Output: First Instance\n",
    "\n",
    "# Attempting to create a second instance will actually refer to the existing instance\n",
    "singleton_instance2 = SingletonClass(\"Second Instance\")\n",
    "\n",
    "# Accessing the data attribute of the first instance\n",
    "print(singleton_instance1.data)  # Output: Second Instance\n",
    "print(singleton_instance2.data)  # Output: Second Instance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05344851",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dbc40954",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Math', 'Science', 'History']\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, subjects):\n",
    "        self.subjects = subjects\n",
    "\n",
    "# Example usage:\n",
    "# Creating an instance of the Student class with a list of subjects\n",
    "student1 = Student([\"Math\", \"Science\", \"History\"])\n",
    "\n",
    "# Accessing the subjects attribute\n",
    "print(student1.subjects)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b16c1d2f",
   "metadata": {},
   "source": [
    "#### 18. What is the purpose of the `__del__` method in Python classes, and how does it relate to constructors?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5f15adad",
   "metadata": {},
   "source": [
    "-> the __del__ method in python is a special method used for cleaning up resources or performing finialization when an object is about to be destroyed\n",
    "-> it is called when an object is no longer in use and is ready to be garbage collected\n",
    "-> the purpoose of the __del__ method is to define the actions that should be taken before the object is removed from memory \n",
    "\n",
    "-> it is important to note that __del__ method is not guaranteed to be called at specific time. and its use can lead to unpredictability in certain scenarios\n",
    "-> instead of relying on __del__ it is often recommended to use context managers or explicitly close resources when they are no longer needed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6338e314",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Object A created.\n",
      "Object B created.\n",
      "Object A is being destroyed.\n",
      "Object B is being destroyed.\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        print(f\"Object {self.name} created.\")\n",
    "\n",
    "    def __del__(self):\n",
    "        print(f\"Object {self.name} is being destroyed.\")\n",
    "\n",
    "# Creating instances of the class\n",
    "obj1 = MyClass(\"A\")\n",
    "obj2 = MyClass(\"B\")\n",
    "\n",
    "# Deleting references to the objects\n",
    "del obj1\n",
    "del obj2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c361995",
   "metadata": {},
   "source": [
    "#### 19. Explain the use of constructor chaining in Python. Provide a practical example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2a7e334a",
   "metadata": {},
   "source": [
    "-> Constructor chaining in Python refers to the ability of a constructor in a derived class to call the constructor of its base class. \n",
    "-> This allows the initialization logic of the base class to be executed before the derived class's initialization \n",
    "-> the process ensures that attributes and behaviors from the base class are properly set up before any additional logic in the derviced class method \n",
    "\n",
    "example "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4704418c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal constructor called for Dog\n",
      "Dog constructor called for Golden Retriever, 3 years old\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, species):\n",
    "        self.species = species\n",
    "        print(f\"Animal constructor called for {self.species}\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def __init__(self, breed, age):\n",
    "        # Call the constructor of the base class (Animal)\n",
    "        super().__init__(\"Dog\")\n",
    "        self.breed = breed\n",
    "        self.age = age\n",
    "        print(f\"Dog constructor called for {self.breed}, {self.age} years old\")\n",
    "\n",
    "# Create an instance of the Dog class\n",
    "dog_instance = Dog(\"Golden Retriever\", 3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17a9f557",
   "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": 9,
   "id": "67d14b33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Make: Toyota\n",
      "Model: Supra\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    def __init__(self, make, model):\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Make: {self.make}\")\n",
    "        print(f\"Model: {self.model}\")\n",
    "\n",
    "# Creating an instance of the Car class with default constructor values\n",
    "car_instance = Car(\"Toyota\", \"Supra\")\n",
    "\n",
    "# Displaying car information\n",
    "car_instance.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0745897f",
   "metadata": {},
   "source": [
    "# Inheritance:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb6c515c",
   "metadata": {},
   "source": [
    "#### 1. What is inheritance in Python? Explain its significance in object-oriented programming.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "84da5eae",
   "metadata": {},
   "source": [
    "-> Inheritance in Python is a mechanism that allows class to inherit the properties and behavior from another class. \n",
    "-> the derived class can reuse the code of the base class, and it can also be extended or override the functionality of the base class\n",
    "\n",
    "-> Inheritance is a fundamental concept of OOP and has several singnificant advantages like code reusability, Modularity, Polymorphism, Method Overriding, Ease of maintenance \n",
    "\n",
    "example of inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9d7fd9b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal speaks\n",
      "Animal speaks\n",
      "Dog barks\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Animal speaks\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def bark(self):\n",
    "        print(\"Dog barks\")\n",
    "\n",
    "# Creating instances of the classes\n",
    "animal_instance = Animal()\n",
    "dog_instance = Dog()\n",
    "\n",
    "# Calling methods\n",
    "animal_instance.speak()  # Output: Animal speaks\n",
    "dog_instance.speak()     # Output: Animal speaks (inherited from Animal class)\n",
    "dog_instance.bark()      # Output: Dog barks\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "549e6af1",
   "metadata": {},
   "source": [
    "#### 2. Differentiate between single inheritance and multiple inheritance in Python. Provide examples for each.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "67b07c44",
   "metadata": {},
   "source": [
    "*) Single Ineheritance\n",
    "\n",
    "-> In single inheritance, a class can inherit from only one base class. This means that a derived class can extend or override the functionality of a single parent class. Single inheritance is simpler and more straightforward compared to multiple inheritance.\n",
    "\n",
    "example "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9628cbe9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal speaks\n",
      "Dog barks\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Animal speaks\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def bark(self):\n",
    "        print(\"Dog barks\")\n",
    "\n",
    "# Creating an instance of the Dog class\n",
    "dog_instance = Dog()\n",
    "\n",
    "# Calling methods\n",
    "dog_instance.speak()  # Output: Animal speaks (inherited from Animal class)\n",
    "dog_instance.bark()   # Output: Dog barks\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ad3234a5",
   "metadata": {},
   "source": [
    "*) Multiple Inheritance:\n",
    "-> In multiple inheritance, a class can inherit from more than one base class. This allows a derived class to inherit and combine the properties and behaviors of multiple parent classes. While powerful, multiple inheritance can lead to complex class hierarchies and potential conflicts, so it should be used carefully."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f061678a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can fly\n",
      "Can swim\n"
     ]
    }
   ],
   "source": [
    "class Flyable:\n",
    "    def fly(self):\n",
    "        print(\"Can fly\")\n",
    "\n",
    "class Swimmable:\n",
    "    def swim(self):\n",
    "        print(\"Can swim\")\n",
    "\n",
    "class FlyingFish(Flyable, Swimmable):\n",
    "    pass\n",
    "\n",
    "# Creating an instance of the FlyingFish class\n",
    "flying_fish_instance = FlyingFish()\n",
    "\n",
    "# Calling methods\n",
    "flying_fish_instance.fly()  # Output: Can fly\n",
    "flying_fish_instance.swim()  # Output: Can swim\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "618b05e7",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8fce814a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Color: Blue\n",
      "Speed: 60\n",
      "Brand: Toyota\n"
     ]
    }
   ],
   "source": [
    "class Vehicle:\n",
    "    def __init__(self, color, speed):\n",
    "        self.color = color\n",
    "        self.speed = speed\n",
    "\n",
    "class Car(Vehicle):\n",
    "    def __init__(self, color, speed, brand):\n",
    "        # Call the constructor of the base class (Vehicle)\n",
    "        super().__init__(color, speed)\n",
    "        self.brand = brand\n",
    "\n",
    "# Creating a Car object\n",
    "car_obj = Car(color=\"Blue\", speed=60, brand=\"Toyota\")\n",
    "\n",
    "# Accessing attributes\n",
    "print(f\"Color: {car_obj.color}\")\n",
    "print(f\"Speed: {car_obj.speed}\")\n",
    "print(f\"Brand: {car_obj.brand}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb95eef5",
   "metadata": {},
   "source": [
    "#### 4. Explain the concept of method overriding in inheritance. Provide a practical example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "75732088",
   "metadata": {},
   "source": [
    "-> Method overriding is a concept in object-oriented programming where a subclass provides a specific implementation for a method that is already defined in its superclass. When a method in the subclass has the same name, return type, and parameters as a method in the superclass, it is said to override the method in the superclass.\n",
    "-> The primary purpose of method overriding is to customize or extend the behavior of the inherited method in the subclass. This allows a more specialized implementation to be provided in the derived class while maintaining a common interface with the base class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "23c6a775",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generic animal sound\n",
      "Woof! Woof!\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",
    "        print(\"Woof! Woof!\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Meow!\")\n",
    "\n",
    "# Creating instances\n",
    "animal = Animal()\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "# Calling the make_sound method on each object\n",
    "animal.make_sound()  # Output: Generic animal sound\n",
    "dog.make_sound()     # Output: Woof! Woof!\n",
    "cat.make_sound()     # Output: Meow!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af3c5d2c",
   "metadata": {},
   "source": [
    "#### 5. How can you access the methods and attributes of a parent class from a child class in Python? Give an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "82341265",
   "metadata": {},
   "source": [
    "-> In python, you can access the methods and attributes of parent class from a child class using super() function. the super() function returns a temporary object of the superclass, which allows you to call its method\n",
    "\n",
    "example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5a142b27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parent class:John\n",
      "child class:Additional Information\n"
     ]
    }
   ],
   "source": [
    "class ParentClass:\n",
    "    def __init__(self,name):\n",
    "        self.name = name\n",
    "        \n",
    "    def display_name(self):\n",
    "        print(f\"Parent class:{self.name}\")\n",
    "        \n",
    "class ChildClass(ParentClass):\n",
    "    def __init__(self,name,additional_info):\n",
    "        super().__init__(name)\n",
    "        self.additional_info = additional_info\n",
    "        \n",
    "    def display_info(self):\n",
    "        super().display_name() #Calling the method of parent class\n",
    "        print(f\"child class:{self.additional_info}\")\n",
    "       \n",
    "    \n",
    "# Create an instance of the child class\n",
    "child_instance = ChildClass(name=\"John\", additional_info=\"Additional Information\")\n",
    "\n",
    "# Call methods from the child class\n",
    "child_instance.display_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b115298a",
   "metadata": {},
   "source": [
    "#### 6. Discuss the use of the `super()` function in Python inheritance. When and why is it used? Provide an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "323fee5f",
   "metadata": {},
   "source": [
    "-> In Python, Super() function is used in the context of inheritance to refer to the parent class\n",
    "-> it provides a way to call methods from the parent class in a derived class\n",
    "-> the primary purpose of super() is to enable cooperative multiple inheritance  and ensure that all the necessary initialization and behavior of the parent class are properly executed. \n",
    "\n",
    "1) Initialization of the Parent Class:\n",
    "-> super() is commonly used in the __init__ method of a child class to call the constructor of the parent class. This is crucial for proper initialization and can help avoid code duplication.\n",
    "\n",
    "2) Method Overriding:\n",
    "-> When a method is overridden in a child class, using super() allows you to invoke the overridden method in the parent class, maintaining the functionality of the parent class while extending or modifying it in the child class.\n",
    "\n",
    "3) Cooperative Multiple Inheritance:\n",
    "-> In cases where a class inherits from multiple classes (multiple inheritance), super() helps in establishing a consistent and predictable method resolution order (MRO). It ensures that each class in the inheritance hierarchy gets a chance to execute its methods in a proper sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "af88a94e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Buddy is a Dog of breed Golden Retriever.\n",
      "Generic animal sound\n",
      "Bark!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, species):\n",
    "        self.species = species\n",
    "\n",
    "    def make_sound(self):\n",
    "        print(\"Generic animal sound\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def __init__(self, name, breed):\n",
    "        super().__init__(species=\"Dog\")\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "\n",
    "    def make_sound(self):\n",
    "        super().make_sound()  # Call the make_sound method of the parent class\n",
    "        print(\"Bark!\")\n",
    "\n",
    "# Create an instance of the Dog class\n",
    "my_dog = Dog(name=\"Buddy\", breed=\"Golden Retriever\")\n",
    "\n",
    "# Call methods from the Dog class\n",
    "print(f\"{my_dog.name} is a {my_dog.species} of breed {my_dog.breed}.\")\n",
    "my_dog.make_sound()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a53c3a26",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "61ffabfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal speaks:\n",
      "Generic animal sound\n",
      "\n",
      "Dog speaks:\n",
      "Woof!\n",
      "\n",
      "Cat speaks:\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"Generic animal sound\")\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",
    "# Example usage\n",
    "animal_instance = Animal()\n",
    "dog_instance = Dog()\n",
    "cat_instance = Cat()\n",
    "\n",
    "print(\"Animal speaks:\")\n",
    "animal_instance.speak()\n",
    "\n",
    "print(\"\\nDog speaks:\")\n",
    "dog_instance.speak()\n",
    "\n",
    "print(\"\\nCat speaks:\")\n",
    "cat_instance.speak()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87f99423",
   "metadata": {},
   "source": [
    "#### 8. Explain the role of the `isinstance()` function in Python and how it relates to inheritance.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "abb5a00d",
   "metadata": {},
   "source": [
    "-> The isinstance() function in Python is used to check if an object belongs to a particular class or is an instance of a class. It plays a crucial role in understanding the inheritance hierarchy of classes. The isinstance() function is particularly useful when dealing with polymorphism, where objects of different classes share a common interface through inheritance.\n",
    "\n",
    "1) Checking Instance of a Specific Class:\n",
    "-> You can use isinstance() to check if an object is an instance of a particular class. This is a simple type-checking mechanism."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "73eba799",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    pass\n",
    "\n",
    "my_dog = Dog()\n",
    "\n",
    "print(isinstance(my_dog, Dog))    # True\n",
    "print(isinstance(my_dog, Animal)) # True, because Dog is a subclass of Animal\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "3bb20e51",
   "metadata": {},
   "source": [
    "2) Checking Instance of Any Class in a Tuple:\n",
    "-> isinstance() can also check if an object is an instance of any of the classes in a tuple. This is useful when you want to check if an object is one of several possible types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3de91a30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    pass\n",
    "\n",
    "class Cat(Animal):\n",
    "    pass\n",
    "\n",
    "my_dog = Dog()\n",
    "\n",
    "print(isinstance(my_dog, (Dog, Cat)))   # True, because my_dog is a Dog\n",
    "print(isinstance(my_dog, (Animal, Cat)))# True, because my_dog is an Animal (or Cat)\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "29821807",
   "metadata": {},
   "source": [
    "2) Checking for Parent Class:\n",
    "-> isinstance() is often used to check if an object is an instance of a parent class. This is useful when you want to perform different actions based on the type of the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f668baf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's an animal!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    pass\n",
    "\n",
    "class Cat(Animal):\n",
    "    pass\n",
    "\n",
    "my_dog = Dog()\n",
    "\n",
    "if isinstance(my_dog, Animal):\n",
    "    print(\"It's an animal!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1355ea99",
   "metadata": {},
   "source": [
    "#### 9. What is the purpose of the `issubclass()` function in Python? Provide an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "a98935bd",
   "metadata": {},
   "source": [
    "-> The issubclass() function in Python is used to check if a given class is a subclass of another class. It helps in determining the inheritance relationship between classes. The syntax for issubclass() is issubclass(class, classinfo)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ddab8260",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    pass\n",
    "\n",
    "class Mammal(Animal):\n",
    "    pass\n",
    "\n",
    "class Dog(Mammal):\n",
    "    pass\n",
    "\n",
    "# Check if Dog is a subclass of Animal\n",
    "print(issubclass(Dog, Animal))  # True, because Dog is a subclass of Animal\n",
    "\n",
    "# Check if Mammal is a subclass of Animal\n",
    "print(issubclass(Mammal, Animal))  # True, because Mammal is a subclass of Animal\n",
    "\n",
    "# Check if Mammal is a subclass of Dog\n",
    "print(issubclass(Mammal, Dog))  # False, because Mammal is not a subclass of Dog\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a67c03db",
   "metadata": {},
   "source": [
    "#### 10. Discuss the concept of constructor inheritance in Python. How are constructors inherited in child classes?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "516e6aca",
   "metadata": {},
   "source": [
    "-> In Python, constructor inheritance refers to how the constructors (initialization methods) of parent classes are inherited by their child classes. When a child class is created, it can either explicitly call the constructor of its parent class using super().__init__() or rely on implicit inheritance if it doesn't define its own constructor.\n",
    "\n",
    "1) implicit Inheritance:\n",
    "-> If a child class doesn't define its own constructor, it implicitly inherits the constructor of its immediate parent class. This means that when you create an instance of the child class, the constructor of the parent class is automatically called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9ea9f641",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parent constructor called.\n"
     ]
    }
   ],
   "source": [
    "class ParentClass:\n",
    "    def __init__(self):\n",
    "        print(\"Parent constructor called.\")\n",
    "\n",
    "class ChildClass(ParentClass):\n",
    "    pass\n",
    "\n",
    "# Creating an instance of the child class\n",
    "child_instance = ChildClass()\n",
    "# Output: Parent constructor called.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2cbf72cc",
   "metadata": {},
   "source": [
    "2) Explicit Inheritance using super()\n",
    "-> If a child class defines its own constructor and still wants to invoke the constructor of its parent class, it can use the super().__init__() method. This allows the child class to add additional initialization logic while still benefiting from the initialization logic in the parent class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b723773f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parent constructor called.\n",
      "Child constructor called.\n"
     ]
    }
   ],
   "source": [
    "class ParentClass:\n",
    "    def __init__(self):\n",
    "        print(\"Parent constructor called.\")\n",
    "\n",
    "class ChildClass(ParentClass):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        print(\"Child constructor called.\")\n",
    "\n",
    "# Creating an instance of the child class\n",
    "child_instance = ChildClass()\n",
    "# Output:\n",
    "# Parent constructor called.\n",
    "# Child constructor called.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ffb53100",
   "metadata": {},
   "source": [
    "3) Multiple Inheritance and super() :\n",
    "-> In cases of multiple inheritance, the super() function plays a crucial role in determining the order in which constructors are called. The method resolution order (MRO) is used to decide which constructor is executed first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2298b26f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor of class D\n",
      "Constructor of class B\n",
      "Constructor of class C\n",
      "Constructor of class A\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        print(\"Constructor of class A\")\n",
    "\n",
    "class B(A):\n",
    "    def __init__(self):\n",
    "        print(\"Constructor of class B\")\n",
    "        super().__init__()\n",
    "\n",
    "class C(A):\n",
    "    def __init__(self):\n",
    "        print(\"Constructor of class C\")\n",
    "        super().__init__()\n",
    "\n",
    "class D(B, C):\n",
    "    def __init__(self):\n",
    "        print(\"Constructor of class D\")\n",
    "        super().__init__()\n",
    "\n",
    "# Creating an instance of the class D\n",
    "instance_d = D()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd95f476",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5621e1cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the circle: 78.54\n",
      "Area of the rectangle: 24\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "class Shape:\n",
    "    def area(self):\n",
    "        # This is a placeholder method that should be overridden by child classes\n",
    "        pass\n",
    "\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def area(self):\n",
    "        return math.pi * self.radius**2\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "# Example usage\n",
    "circle_instance = Circle(radius=5)\n",
    "rectangle_instance = Rectangle(width=4, height=6)\n",
    "\n",
    "print(f\"Area of the circle: {circle_instance.area():.2f}\")\n",
    "print(f\"Area of the rectangle: {rectangle_instance.area()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4857f8f7",
   "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.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "7db7e513",
   "metadata": {},
   "source": [
    "-> Abstract base Classes(ABCs) in python are a way to define a common interface for a group of related classes. An abstract base class cannot be instatiated isself: instead, it serves as a blueprint for other classes, ensuring that they implement certain methods of properties\n",
    "\n",
    "-> ABCs are defined using the abc module in Python. The ABC class from this module is used as a base class for creating abstract base classes. The abstractmethod decorator is used to declare abstract methods within these classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "296e584e",
   "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  # Approximation of pi for simplicity\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    def area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "# Example usage\n",
    "circle_instance = Circle(radius=5)\n",
    "rectangle_instance = Rectangle(width=4, height=6)\n",
    "\n",
    "print(f\"Area of the circle: {circle_instance.area():.2f}\")\n",
    "print(f\"Area of the rectangle: {rectangle_instance.area()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edd81d59",
   "metadata": {},
   "source": [
    "#### 13. How can you prevent a child class from modifying certain attributes or methods inherited from a parent class in Python?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5b6bbaed",
   "metadata": {},
   "source": [
    "-> In Python, you can control the visibility and modification of attributes and methods in a class through encapsulation and access modifiers. While Python does not have explicit access modifiers like some other languages (e.g., private or protected keywords), it follows a convention of using underscores to indicate the level of visibility.\n",
    "\n",
    "1) Use Single Leading Underscore:\n",
    "-> By convention, a single leading underscore _ before an attribute or method name indicates that it is intended to be protected. It signals to other developers that the attribute or method is intended for internal use and should not be accessed or modified directly by subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b6fac8b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am protected!\n",
      "This method is protected.\n"
     ]
    }
   ],
   "source": [
    "class ParentClass:\n",
    "    def __init__(self):\n",
    "        self._protected_attribute = \"I am protected!\"\n",
    "\n",
    "    def _protected_method(self):\n",
    "        print(\"This method is protected.\")\n",
    "\n",
    "class ChildClass(ParentClass):\n",
    "    def use_protected_attribute(self):\n",
    "        print(self._protected_attribute)\n",
    "\n",
    "    def call_protected_method(self):\n",
    "        self._protected_method()\n",
    "\n",
    "# Example usage\n",
    "child_instance = ChildClass()\n",
    "child_instance.use_protected_attribute() \n",
    "child_instance.call_protected_method()  \n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2be2655c",
   "metadata": {},
   "source": [
    "2) Name Mangling (Double Leading Underscore):\n",
    "-> If you want to make it more difficult for a child class to accidentally override a method or attribute, you can use name mangling by prefixing a double underscore __. This makes the attribute or method name less readable, and it is more challenging for a subclass to modify."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "aeecf34f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ParentClass:\n",
    "    def __init__(self):\n",
    "        self.__mangled_attribute = \"I am mangled!\"\n",
    "\n",
    "    def __mangled_method(self):\n",
    "        print(\"This method is mangled.\")\n",
    "\n",
    "class ChildClass(ParentClass):\n",
    "    def use_mangled_attribute(self):\n",
    "        print(self.__mangled_attribute)  # This will raise an AttributeError\n",
    "\n",
    "    def call_mangled_method(self):\n",
    "        self.__mangled_method()  # This will raise an AttributeError\n",
    "\n",
    "# Example usage\n",
    "child_instance = ChildClass()\n",
    "# Uncommenting the lines below will raise an AttributeError\n",
    "# child_instance.use_mangled_attribute()\n",
    "# child_instance.call_mangled_method()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75b417ab",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "af1c7591",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee: John Doe, Salary: $50000\n",
      "Manager: Jane Smith, Salary: $70000, Department: Human Resources\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",
    "        # Call the constructor of the parent class using super()\n",
    "        super().__init__(name, salary)\n",
    "        self.department = department\n",
    "\n",
    "# Example usage\n",
    "employee_instance = Employee(name=\"John Doe\", salary=50000)\n",
    "manager_instance = Manager(name=\"Jane Smith\", salary=70000, department=\"Human Resources\")\n",
    "\n",
    "print(f\"Employee: {employee_instance.name}, Salary: ${employee_instance.salary}\")\n",
    "print(f\"Manager: {manager_instance.name}, Salary: ${manager_instance.salary}, Department: {manager_instance.department}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69ce883b",
   "metadata": {},
   "source": [
    "#### 15. Discuss the concept of method overloading in Python inheritance. How does it differ from method overriding?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9081281f",
   "metadata": {},
   "source": [
    "-> Method overloading and method overriding are two concepts in object-oriented programming, and they have distinct meanings in the context of Python inheritance\n",
    "\n",
    "1) Method Overloading \n",
    "-> Method overloading refers to the ability to define multiple methods in a class with the same name but with different parameters. Python, unlike some other programming languages, does not support traditional method overloading where you can have multiple methods with the same name but different parameter types or numbers. However, you can achieve a form of method overloading through default parameter values and variable-length argument lists.\n",
    "\n",
    "2) Method Overriding:\n",
    "-> Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. The overridden method in the subclass should have the same signature (name and parameters) as the method in the superclass.\n",
    "\n",
    "\n",
    "*) Differences \n",
    "\n",
    "1) Parameter Signature:\n",
    "-> Method overloading involves defining multiple methods with the same name but different parameter lists. In Python, this is achieved through default parameter values and variable-length argument lists.\n",
    "-> Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. The signature (name and parameters) of the overridden method must match that of the method in the superclass.\n",
    "\n",
    "2) Syntax: \n",
    "-> Method overloading is a result of the ability to define multiple methods with the same name but different parameter lists.\n",
    "-> Method overriding is explicitly done by defining a method in the subclass with the same name as the method in the superclass."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2c8bb25",
   "metadata": {},
   "source": [
    "#### 16. Explain the purpose of the `__init__()` method in Python inheritance and how it is utilized in child classes.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ea423417",
   "metadata": {},
   "source": [
    "-> The __init__() method in Python is a special method, also known as a constructor, that is automatically called when an object is created from a class. It plays a crucial role in initializing the attributes of an object. In the context of inheritance, the __init__() method is often used in both the parent and child classes.\n",
    "\n",
    "Purpose of __init__() method:\n",
    "\n",
    "1) Initialization:\n",
    "-> The primary purpose of the __init__() method is to initialize the attributes of an object when it is created. It allows you to set initial values for the attributes of the object.\n",
    "\n",
    "2) Attribute Assignment:\n",
    "-> It is used to assign values to the attributes of the object, either based on the arguments passed during object creation or with default values specified in the method.\n",
    "\n",
    "3) Constructor Chain:\n",
    "-> In the context of inheritance, the __init__() method is often called the constructor of a class. When a child class is created, its __init__() method may call the __init__() method of its parent class using super().__init__() to ensure that attributes from the parent class are properly initialized.\n",
    "\n",
    "\n",
    "Utilization in Child Classes:\n",
    "\n",
    "1) Inheriting Attributes:\n",
    "-> Child classes can inherit the __init__() method from their parent class. If the child class defines its own __init__() method, it can call the parent class' __init__() method using super().__init__() to initialize attributes inherited from the parent class.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ce820841",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ParentClass:\n",
    "    def __init__(self, attribute1, attribute2):\n",
    "        self.attribute1 = attribute1\n",
    "        self.attribute2 = attribute2\n",
    "\n",
    "class ChildClass(ParentClass):\n",
    "    def __init__(self, attribute1, attribute2, attribute3):\n",
    "        super().__init__(attribute1, attribute2)  # Call the parent class constructor\n",
    "        self.attribute3 = attribute3"
   ]
  },
  {
   "cell_type": "raw",
   "id": "567be25c",
   "metadata": {},
   "source": [
    "2) Adding New Attributes:\n",
    "-> Child classes can add their own attributes in addition to those inherited from the parent class. The __init__() method in the child class takes care of initializing these additional attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6dd91a0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ParentClass:\n",
    "    def __init__(self, attribute1, attribute2):\n",
    "        self.attribute1 = attribute1\n",
    "        self.attribute2 = attribute2\n",
    "\n",
    "class ChildClass(ParentClass):\n",
    "    def __init__(self, attribute1, attribute2, attribute3):\n",
    "        super().__init__(attribute1, attribute2)\n",
    "        self.attribute3 = attribute3\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "29d31437",
   "metadata": {},
   "source": [
    "3) Custom Initialization Logic:\n",
    "-> Child classes can provide custom initialization logic specific to their own attributes. The __init__() method in the child class can include additional steps or computations necessary for the child class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "792c744f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ParentClass:\n",
    "    def __init__(self, attribute1, attribute2):\n",
    "        self.attribute1 = attribute1\n",
    "        self.attribute2 = attribute2\n",
    "\n",
    "class ChildClass(ParentClass):\n",
    "    def __init__(self, attribute1, attribute2, attribute3):\n",
    "        super().__init__(attribute1, attribute2)\n",
    "        self.attribute3 = attribute3\n",
    "        # Additional initialization logic specific to ChildClass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fefb1710",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "49c4deaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generic Bird:\n",
      "Generic bird flying\n",
      "\n",
      "Eagle:\n",
      "Eagle soaring high in the sky\n",
      "\n",
      "Sparrow:\n",
      "Sparrow fluttering from branch to branch\n"
     ]
    }
   ],
   "source": [
    "class Bird:\n",
    "    def fly(self):\n",
    "        print(\"Generic bird flying\")\n",
    "\n",
    "class Eagle(Bird):\n",
    "    def fly(self):\n",
    "        print(\"Eagle soaring high in the sky\")\n",
    "\n",
    "class Sparrow(Bird):\n",
    "    def fly(self):\n",
    "        print(\"Sparrow fluttering from branch to branch\")\n",
    "\n",
    "# Example usage\n",
    "generic_bird = Bird()\n",
    "eagle_instance = Eagle()\n",
    "sparrow_instance = Sparrow()\n",
    "\n",
    "print(\"Generic Bird:\")\n",
    "generic_bird.fly()  # Outputs: Generic bird flying\n",
    "\n",
    "print(\"\\nEagle:\")\n",
    "eagle_instance.fly()  # Outputs: Eagle soaring high in the sky\n",
    "\n",
    "print(\"\\nSparrow:\")\n",
    "sparrow_instance.fly()  # Outputs: Sparrow fluttering from branch to branch\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eea749c0",
   "metadata": {},
   "source": [
    "#### 18. What is the \"diamond problem\" in multiple inheritance, and how does Python address it?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5afb29b7",
   "metadata": {},
   "source": [
    "-> The \"diamond problem\" is a challenge that arises in object-oriented programming languages that support multiple inheritance. It occurs when a class inherits from two classes that have a common ancestor. This situation creates ambiguity when it comes to method resolution—specifically, determining which version of a method should be called when it is inherited from both parent classes.\n",
    "\n",
    "How Python Addresses the Diamond Problem:\n",
    "\n",
    "-> Python uses a mechanism called \"C3 linearization\" or \"C3 superclass linearization\" to address the diamond problem in multiple inheritance. C3 linearization ensures a consistent and predictable order in which base classes are considered during method resolution.\n",
    "\n",
    "-> When a method is called on an instance of a class, Python follows the C3 linearization algorithm to determine the order in which the base classes are considered for method resolution. The algorithm aims to preserve the order specified in the class definition while ensuring that each class is considered only once in the hierarchy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "4ef84356",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class C\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def foo(self):\n",
    "        print(\"Class A\")\n",
    "\n",
    "class B(A):\n",
    "    pass\n",
    "\n",
    "class C(A):\n",
    "    def foo(self):\n",
    "        print(\"Class C\")\n",
    "\n",
    "class D(B, C):\n",
    "    pass\n",
    "\n",
    "# Example usage\n",
    "obj_d = D()\n",
    "obj_d.foo()  # Outputs: Class C\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ce829a7",
   "metadata": {},
   "source": [
    "#### 19. Discuss the concept of \"is-a\" and \"has-a\" relationships in inheritance, and provide examples of each.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "58236a09",
   "metadata": {},
   "source": [
    "-> The concepts of \"is-a\" and \"has-a\" relationships are fundamental in object-oriented programming, particularly in the context of inheritance and composition. They help define the relationships between classes and objects."
   ]
  },
  {
   "cell_type": "raw",
   "id": "dda1e560",
   "metadata": {},
   "source": [
    "1) \"Is-a\" Relationship:\n",
    "-> The \"is-a\" relationship represents inheritance and is often expressed using the extends or inherits from relationships. It signifies that an object of a derived class \"is a\" specialized version of an object of the base class. In other words, a subclass \"is a\" type of its superclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f08caa2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def make_sound(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "# Example usage\n",
    "my_dog = Dog()\n",
    "my_dog.make_sound()  # Outputs: Woof!\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "81d04195",
   "metadata": {},
   "source": [
    "1) \"Has-a\" Relationship:\n",
    "-> The \"has-a\" relationship represents composition and is often expressed using attributes or member variables. It signifies that a class \"has a\" component or part, but it is not a specialized version of that component. In other words, a class has a certain object or functionality, but it is not necessarily a type of that object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b6714dac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car started\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()\n",
    "\n",
    "    def start(self):\n",
    "        print(\"Car started\")\n",
    "        self.engine.start()\n",
    "\n",
    "# Example usage\n",
    "my_car = Car()\n",
    "my_car.start()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88daa8b3",
   "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": 24,
   "id": "2dd1aff7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student Information:\n",
      "Name: John Doe, Age: 20\n",
      "Student ID: S12345\n",
      "John Doe is studying.\n",
      "\n",
      "Professor Information:\n",
      "Name: Dr. Smith, Age: 40\n",
      "Employee ID: P98765\n",
      "Dr. Smith is teaching.\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Name: {self.name}, Age: {self.age}\")\n",
    "\n",
    "\n",
    "class Student(Person):\n",
    "    def __init__(self, name, age, student_id):\n",
    "        super().__init__(name, age)\n",
    "        self.student_id = student_id\n",
    "\n",
    "    def display_info(self):\n",
    "        super().display_info()\n",
    "        print(f\"Student ID: {self.student_id}\")\n",
    "\n",
    "    def study(self):\n",
    "        print(f\"{self.name} is studying.\")\n",
    "\n",
    "\n",
    "class Professor(Person):\n",
    "    def __init__(self, name, age, employee_id):\n",
    "        super().__init__(name, age)\n",
    "        self.employee_id = employee_id\n",
    "\n",
    "    def display_info(self):\n",
    "        super().display_info()\n",
    "        print(f\"Employee ID: {self.employee_id}\")\n",
    "\n",
    "    def teach(self):\n",
    "        print(f\"{self.name} is teaching.\")\n",
    "\n",
    "\n",
    "# Example usage\n",
    "student1 = Student(name=\"John Doe\", age=20, student_id=\"S12345\")\n",
    "professor1 = Professor(name=\"Dr. Smith\", age=40, employee_id=\"P98765\")\n",
    "\n",
    "print(\"Student Information:\")\n",
    "student1.display_info()\n",
    "student1.study()\n",
    "\n",
    "print(\"\\nProfessor Information:\")\n",
    "professor1.display_info()\n",
    "professor1.teach()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8851554",
   "metadata": {},
   "source": [
    "# Encapsulation:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecb45d8e",
   "metadata": {},
   "source": [
    "#### 1. Explain the concept of encapsulation in Python. What is its role in object-oriented programming?"
   ]
  },
  {
   "cell_type": "raw",
   "id": "17ccc54e",
   "metadata": {},
   "source": [
    "-> Encapsulation is one of the fundamental principles of object oriented programming and refers to the bundling of data and the methods that operates on the data into a single unit called a class\n",
    "-> encapsulation helps in hiding the internal implementation details of an object and exposing only what is necessary for the outside world  to interact with it. it promotes the concept of information hiding and data abstraction "
   ]
  },
  {
   "cell_type": "raw",
   "id": "73189b24",
   "metadata": {},
   "source": [
    "1) Data Hiding:\n",
    "-> Encapsulation allows the hiding of the internal state of an object from the outside world. This is achieved by marking attributes as private, meaning they can only be accessed and modified within the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0220cd66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self._private_attribute = 42  # Single underscore convention for \"protected\" attribute\n",
    "\n",
    "obj = MyClass()\n",
    "print(obj._private_attribute)  # Accessible from outside, but convention indicates it should be treated as \"protected\"\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9826239e",
   "metadata": {},
   "source": [
    "2) Getter and Setter Methods:\n",
    "-> Encapsulation often involves providing getter and setter methods to access and modify the private attributes of a class. This allows controlled access to the internal state and facilitates data validation or additional logic when accessing or modifying the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "d0d7393a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "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",
    "    def set_private_attribute(self, value):\n",
    "        if value > 0:\n",
    "            self._private_attribute = value\n",
    "\n",
    "obj = MyClass()\n",
    "print(obj.get_private_attribute())  # Using getter\n",
    "obj.set_private_attribute(99)       # Using setter\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "040abb1d",
   "metadata": {},
   "source": [
    "3) Encapsulation for Modularity:\n",
    "-> Encapsulation helps in creating modular and reusable code. The internal implementation details of a class can be changed without affecting the code that uses the class as long as the external interface (public methods and attributes) remains the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "10b70272",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 2022 Toyota's engine is started.\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    def __init__(self, model, year):\n",
    "        self._model = model\n",
    "        self._year = year\n",
    "\n",
    "    def start_engine(self):\n",
    "        print(f\"The {self._year} {self._model}'s engine is started.\")\n",
    "\n",
    "my_car = Car(model=\"Toyota\", year=2022)\n",
    "my_car.start_engine()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90e5d4e6",
   "metadata": {},
   "source": [
    "#### 2. Describe the key principles of encapsulation, including access control and data hiding.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "bfa30036",
   "metadata": {},
   "source": [
    "-> Encapsulation is one of the fundamental principles of object-oriented programming (OOP) and is aimed at bundling the data (attributes or properties) and the methods (functions or procedures) that operate on the data into a single unit known as a class. This concept helps in organizing and structuring code, making it more modular and maintainable. Two key aspects of encapsulation are access control and data hiding."
   ]
  },
  {
   "cell_type": "raw",
   "id": "2b9ed7cb",
   "metadata": {},
   "source": [
    "1) Access Control:\n",
    "-> Public: Public members (attributes and methods) are accessible from any part of the program. They form the interface to the class and are meant to be used by external code.\n",
    "-> Private: Private members are only accessible within the class. They are hidden from external code and are used for internal implementation details. This helps in preventing external interference with the internal state of the object.\n",
    "-> Protected: Protected members are similar to private members but are accessible to subclasses. This allows for a level of access that extends beyond the class itself, but still limits visibility to a certain extent."
   ]
  },
  {
   "cell_type": "raw",
   "id": "915eea4c",
   "metadata": {},
   "source": [
    "2) Data Hiding:\n",
    "-> Private Data Members: Encapsulation involves hiding the implementation details of a class. Private data members ensure that the internal state of an object is not directly accessible from outside the class. This helps in preventing unintended modifications and ensures that the object's state is only altered through well-defined methods (getters and setters).\n",
    "-> Getters and Setters: Instead of directly accessing or modifying the attributes of a class, encapsulation encourages the use of methods (getters and setters) to interact with the object's state. Getters retrieve the value of an attribute, and setters modify the value, often with additional checks or logic to ensure the integrity of the data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d5f7d06",
   "metadata": {},
   "source": [
    "#### 3. How can you achieve encapsulation in Python classes? Provide an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5f36f035",
   "metadata": {},
   "source": [
    "-> In Python, encapsulation can be achieved through the use of private and protected attributes and methods, which are denoted by a single or double underscore prefix. While Python does not enforce strict access control like some other languages, it relies on naming conventions to indicate the intended visibility of attributes and methods. Here's an example demonstrating encapsulation in a Python class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9ecc5daf",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bank:\n",
    "    def __init__(self,account_numer,balance):\n",
    "        self._account_numer = account_numer\n",
    "        self.__balance = balance\n",
    "    \n",
    "    def fetch_balance(self,password):\n",
    "        if password == '1234':\n",
    "            return self.__balance\n",
    "        else:\n",
    "            return 'Incorrect password'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "01290982",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18237"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tmr = Bank(12345,18237)\n",
    "tmr.fetch_balance('1234')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "699fbe12",
   "metadata": {},
   "source": [
    "#### 4. Discuss the difference between public, private, and protected access modifiers in Python.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "66ac044f",
   "metadata": {},
   "source": [
    "1) Public:\n",
    "-> Public members (attributes and methods) are accessible from any part of the program. They form the interface to the class and are meant to be used by external code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "93b3493a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.public_attribute = \"I am public\"\n",
    "        \n",
    "    def public_method(self):\n",
    "        print(\"This is a public method\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58649c33",
   "metadata": {},
   "source": [
    "2) Private\n",
    "-> Private members are only accessible within the class. They are hidden from external code and are used for internal implementation details. This helps in preventing external interference with the internal state of the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31374250",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.__private_attribute = \"I am private\"\n",
    "        \n",
    "    def __private_method(self):\n",
    "        print(\"This is a private method\")\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "95d11ca1",
   "metadata": {},
   "source": [
    "3) Protected\n",
    "-> Protected members are similar to private members but are accessible to subclasses. This allows for a level of access that extends beyond the class itself, but still limits visibility to a certain extent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "65e4a37b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self._protected_attribute = \"I am protected\"\n",
    "        \n",
    "    def _protected_method(self):\n",
    "        print(\"This is a protected method\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "903a49e0",
   "metadata": {},
   "source": [
    "#### 5. Create a Python class called `Person` with a private attribute `__name`. Provide methods to get and set the name attribute.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1e0df6d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__ (self,name):\n",
    "        self.__name = name\n",
    "        \n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "    \n",
    "    def set_name(self,new_name):\n",
    "        self.__name = new_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5bd7b1c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Name: Mit\n",
      "New Name: TMR\n"
     ]
    }
   ],
   "source": [
    "person = Person('Mit')\n",
    "\n",
    "print('Original Name:', person.get_name())\n",
    "\n",
    "person.set_name('TMR')\n",
    "\n",
    "print('New Name:', person.get_name())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9779656",
   "metadata": {},
   "source": [
    "#### 6. Explain the purpose of getter and setter methods in encapsulation. Provide examples.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ef8d7e72",
   "metadata": {},
   "source": [
    "-> Getter and setter methods play a crucial role in encapsulation by providing controlled access to the attributes of a class. They allow you to get (retrieve) and set (modify) the values of private attributes, enabling you to encapsulate the internal state of an object and hide its implementation details."
   ]
  },
  {
   "cell_type": "raw",
   "id": "ce4b76a4",
   "metadata": {},
   "source": [
    "1) Getter Methods:\n",
    "\n",
    "-> Purpose: Getter methods, also known as accessor methods, are used to retrieve the values of private attributes. They provide a way for external code to access the state of an object without directly accessing its private attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6f6d91c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person's Name: John Doe\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.__name = name\n",
    "\n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "\n",
    "# Creating an instance of the Person class\n",
    "person = Person(\"John Doe\")\n",
    "\n",
    "# Using the getter method to access the private attribute\n",
    "print(\"Person's Name:\", person.get_name())\n",
    "\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "1a439216",
   "metadata": {},
   "source": [
    "2) Setter Methods:\n",
    "\n",
    "-> Purpose: Setter methods, also known as mutator methods, are used to modify the values of private attributes. They provide a controlled way to update the internal state of an object, often with additional validation or logic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f5d66ae2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid balance value\n"
     ]
    }
   ],
   "source": [
    "class BankAccount:\n",
    "    def __init__(self, balance):\n",
    "        self.__balance = balance\n",
    "\n",
    "    def set_balance(self, new_balance):\n",
    "        if new_balance >= 0:\n",
    "            self.__balance = new_balance\n",
    "        else:\n",
    "            print(\"Invalid balance value\")\n",
    "\n",
    "# Creating an instance of the BankAccount class\n",
    "account = BankAccount(1000)\n",
    "\n",
    "# Using the setter method to modify the private attribute\n",
    "account.set_balance(1500)\n",
    "\n",
    "# Attempting to set an invalid balance\n",
    "account.set_balance(-500)\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "0b9af984",
   "metadata": {},
   "source": [
    "The purpose of getter and setter methods can be summarized as follows:\n",
    "\n",
    "1) Encapsulation: They encapsulate the internal representation of an object, hiding the implementation details and preventing direct access to the private attributes.\n",
    "2) Controlled Access: They provide a controlled interface for accessing and modifying the state of an object, allowing the class to enforce rules and validations.\n",
    "3) Flexibility: They offer flexibility in modifying the internal implementation of a class without affecting the external code that interacts with the class through its public interface."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9479ea79",
   "metadata": {},
   "source": [
    "#### 7. What is name mangling in Python, and how does it affect encapsulation?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4c56d353",
   "metadata": {},
   "source": [
    "-> Name mangling is a mechanism in Python that adds a prefix to attribute names in order to make them less accessible from outside the class. This is done to implement a form of \"private\" or \"protected\" behavior for attributes, even though Python does not have strict access control like some other programming languages. The name mangling convention involves adding a double underscore (__) as a prefix to an attribute name."
   ]
  },
  {
   "cell_type": "raw",
   "id": "63dd502a",
   "metadata": {},
   "source": [
    "1) Private Attribute:\n",
    "-> If an attribute in a class is named with a double underscore prefix (e.g., __attribute), Python internally changes its name by adding an underscore and the name of the class to it (e.g., _classname__attribute).\n",
    "\n",
    "2) Protected Attribute:\n",
    "-> If an attribute is named with a single underscore prefix (e.g., _attribute), it is considered protected, but there is no name mangling applied. It's a convention rather than a strict enforcement."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "036810ea",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "949ab790",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BankAccount:\n",
    "    def __init__(self,account_number,balance):\n",
    "        self.__account_number = account_number\n",
    "        self.__balance = balance\n",
    "        \n",
    "    def deposit_money(self, account_number,amount):\n",
    "        self.__balance += amount\n",
    "        return self.__balance\n",
    "    \n",
    "    def withdraw_money(self,account_number,withdraw_amount):\n",
    "        if withdraw_amount > self.__balance:\n",
    "            return \"Insufficient Balance\"\n",
    "        else:\n",
    "            self.__balance -= withdraw_amount\n",
    "            return self.__balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f09ec6ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1778"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Person1 = BankAccount('1234',1278)\n",
    "\n",
    "Person1.deposit_money('1234',500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "99c315d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "498"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Person1.withdraw_money('1234',1280)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f05a79b",
   "metadata": {},
   "source": [
    "\n",
    "#### 9. Discuss the advantages of encapsulation in terms of code maintainability and security.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "64bc762d",
   "metadata": {},
   "source": [
    "-> Modularity: Encapsulation promotes modularity by organizing code into well-defined units (classes). Each class encapsulates a set of related attributes and methods, making it easier to understand and maintain specific parts of the code.\n",
    "\n",
    "-> Isolation of Changes: Changes to the internal implementation of a class (e.g., modifying attributes or methods) can be isolated within that class. External code that uses the class's public interface remains unaffected, reducing the risk of unintended side effects and making maintenance more straightforward.\n",
    "\n",
    "-> Easier Debugging: Encapsulation helps in localizing errors and debugging. If an issue arises, developers can focus on the specific class where the problem occurs, rather than searching through the entire codebase."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68a34da4",
   "metadata": {},
   "source": [
    "#### 10. How can you access private attributes in Python? Provide an example demonstrating the use of name mangling.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "8c3ffb1c",
   "metadata": {},
   "source": [
    "-> In Python, Private attributes are intended to be accessed only within the clas where they are defined. However, it's important to note that python does not provide true access control, and The use of single or double underscore prefix is more of a convention than a strict enforcement. \n",
    "\n",
    "-> Despite this, there is a mechanism known as name mangling that sightly obfuscates the name of private attributes, making them less acessible from outside class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a5415d7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is private\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self):\n",
    "        self.__private_attribute = \"this is private\"\n",
    "        \n",
    "ClassObject = MyClass()\n",
    "\n",
    "print(ClassObject._MyClass__private_attribute)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d6f64f1",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "2b5f0de3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student: Mit, ID: S12345\n",
      "Teacher: Mr. TMR, ID: Computer\n",
      "Course: CSCI101, Name: Introduction to Computer Science\n",
      "Students Enrolled in Introduction to Computer Science: [<__main__.Student object at 0x0798AA48>]\n",
      "Courses Taught by Mr. TMR: [<__main__.Course object at 0x0798A430>]\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",
    "    \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 = []\n",
    "        \n",
    "    def get_student_id(self):\n",
    "        return self.__student_id\n",
    "    \n",
    "    def enroll_course(self,course):\n",
    "        self.__courses.append(course)\n",
    "    \n",
    "    def get_course(self):\n",
    "        return self.__courses\n",
    "        \n",
    "class Teacher(Person):\n",
    "    \n",
    "    def __init__(self,name,age,employee_id):\n",
    "        super().__init__(name,age)\n",
    "        self.__employee_id = employee_id\n",
    "        self.__courses_tought = []\n",
    "        \n",
    "    def get_employee_id(self):\n",
    "        return self.__employee_id\n",
    "    \n",
    "    def assign_course(self,course):\n",
    "        self.__courses_tought.append(course)\n",
    "        \n",
    "    def get_courses_taught(self):\n",
    "        return self.__courses_tought\n",
    "    \n",
    "class Course:\n",
    "    \n",
    "    def __init__(self,course_code,course_name):\n",
    "        self.__course_code = course_code\n",
    "        self.__course_name = course_name\n",
    "        self.__students_enrolled = []\n",
    "        \n",
    "    def get_course_code(self):\n",
    "        return self.__course_code\n",
    "    \n",
    "    def get_course_name(self):\n",
    "        return self.__course_name\n",
    "    \n",
    "    def enroll_student(self, student):\n",
    "        self.__students_enrolled.append(student)\n",
    "    \n",
    "    def get_students_enrolled(self):\n",
    "        return self.__students_enrolled\n",
    "    \n",
    "        \n",
    "        \n",
    "#Example Usage \n",
    "\n",
    "student1 = Student(\"Mit\", 18, \"S12345\")\n",
    "teacher1 = Teacher(\"Mr. TMR\", 35,'Computer')\n",
    "course1 = Course(\"CSCI101\", \"Introduction to Computer Science\")\n",
    "\n",
    "\n",
    "print(f\"Student: {student1.get_name()}, ID: {student1.get_student_id()}\")\n",
    "print(f\"Teacher: {teacher1.get_name()}, ID: {teacher1.get_employee_id()}\")\n",
    "print(f\"Course: {course1.get_course_code()}, Name: {course1.get_course_name()}\")\n",
    "\n",
    "# Enrolling a student in a course\n",
    "course1.enroll_student(student1)\n",
    "print(f\"Students Enrolled in {course1.get_course_name()}: {course1.get_students_enrolled()}\")\n",
    "\n",
    "# Assigning a course to a teacher\n",
    "teacher1.assign_course(course1)\n",
    "print(f\"Courses Taught by {teacher1.get_name()}: {teacher1.get_courses_taught()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a8c474f",
   "metadata": {},
   "source": [
    "#### 12. Explain the concept of property decorators in Python and how they relate to encapsulation.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "e98e2437",
   "metadata": {},
   "source": [
    "-> In Python, property decorators are a way to define getter, setter, and deleter methods for class attributes. They provide a convenient and syntactically pleasing way to implement encapsulation principles, particularly when dealing with attributes that require additional logic or validation when getting or setting their values.\n",
    "\n",
    "-> The property decorator is used to create read-only properties, and it is often accompanied by the @property, @<attribute>.setter, and @<attribute>.deleter decorators to define getter, setter, and deleter methods, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "aaffda34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Width: 5\n",
      "Height: 10\n"
     ]
    }
   ],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self,width,height):\n",
    "        self._width = width\n",
    "        self._height = height \n",
    "        \n",
    "    @property\n",
    "    def width(self):\n",
    "        return self._width \n",
    "    \n",
    "    @width.setter\n",
    "    def width(self, value):\n",
    "        if value > 0: \n",
    "            self._width = value \n",
    "        else:\n",
    "            print('Width must be greater than zero ')\n",
    "            \n",
    "            \n",
    "    @property \n",
    "    def height(self):\n",
    "        return self._height \n",
    "    \n",
    "    @height.setter\n",
    "    def height(self,value):\n",
    "        if value > 0:\n",
    "            self._height = value \n",
    "        else:\n",
    "            print('Height Must be greater than 0')\n",
    "            \n",
    "            \n",
    "    @property \n",
    "    def area(self):\n",
    "        return self._width * self._height\n",
    "    \n",
    "rectangle = Rectangle(5,10)\n",
    "\n",
    "print(\"Width:\", rectangle.width)\n",
    "print(\"Height:\", rectangle.height)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "9a98f76d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Width must be greater than zero \n",
      "Height Must be greater than 0\n"
     ]
    }
   ],
   "source": [
    "rectangle.width = -3\n",
    "rectangle.height = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "a5a321a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area: 50\n"
     ]
    }
   ],
   "source": [
    "print(\"Area:\", rectangle.area)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d65c184a",
   "metadata": {},
   "source": [
    "#### 13. What is data hiding, and why is it important in encapsulation? Provide examples.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "056cbc58",
   "metadata": {},
   "source": [
    "-> Data hiding is a concept in object-oriented programming (OOP) that involves restricting the visibility of certain details of a class and its implementation from external code. The idea is to hide the internal representation of an object's state and provide controlled access through well-defined interfaces such as methods or properties. Data hiding is a key aspect of encapsulation, which bundles the data and the methods that operate on the data into a single unit (class).\n",
    "\n",
    "1) Abstraction \n",
    "-> Data hiding allows you to present a simplified and abstract view of an object's behavior to the external world. Instead of exposing the intricate details of the internal state, only relevant information is made accessible through public interfaces.\n",
    "\n",
    "2) Security\n",
    "-> By hiding the implementation details, you prevent external code from directly accessing or modifying the internal state of an object. This helps in preventing unintended modifications and ensures that the object's state is managed in a controlled manner.\n",
    "\n",
    "3) Flexibility: \n",
    "-> Data hiding provides flexibility in changing the internal implementation of a class without affecting the external code that uses the class. As long as the public interface remains unchanged, internal modifications can be made to improve performance, fix bugs, or add new features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "dc734ac8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class test:\n",
    "    def __init__(self):\n",
    "        self.__x = 'TMR'\n",
    "        self._y = 'y'\n",
    "    def __test_meth(self):\n",
    "        return 'This is test class'\n",
    "    \n",
    "    def acceesX(self):\n",
    "        return self.__x\n",
    "    \n",
    "    def update_var(self,data):\n",
    "        self.__x = data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c3a1099b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TMR'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = test()\n",
    "t1._test__x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a4ddbcf",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a3fee7ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee ID: E12345\n",
      "Salary: 50000\n",
      "Yearly bonus: $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, percentage):\n",
    "        if percentage > 0:\n",
    "            bonus = (percentage / 100) * self.__salary\n",
    "            return bonus\n",
    "        else:\n",
    "            print(\"Invalid bonus percentage\")\n",
    "            return 0\n",
    "\n",
    "    # Getter methods to access private attributes\n",
    "    def get_employee_id(self):\n",
    "        return self.__employee_id\n",
    "\n",
    "    def get_salary(self):\n",
    "        return self.__salary\n",
    "\n",
    "# Example usage:\n",
    "employee = Employee(\"E12345\", 50000)\n",
    "\n",
    "# Accessing private attributes using getter methods\n",
    "print(\"Employee ID:\", employee.get_employee_id())\n",
    "print(\"Salary:\", employee.get_salary())\n",
    "\n",
    "# Calculating and printing yearly bonus\n",
    "bonus_percentage = 10  # 10% bonus\n",
    "yearly_bonus = employee.calculate_yearly_bonus(bonus_percentage)\n",
    "print(f\"Yearly bonus: ${yearly_bonus}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0068066",
   "metadata": {},
   "source": [
    "#### 15. Discuss the use of accessors and mutators in encapsulation. How do they help maintain control over attribute access?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "3e5eebaf",
   "metadata": {},
   "source": [
    "-> Accessors and mutators are methods used in object-oriented programming to implement encapsulation by controlling access to class attributes. They provide controlled and well-defined ways to access (getter) abd modify(setters) the values of private attributes. \n",
    "\n",
    "1) Accessors(getters)\n",
    "-> Purpose: Accessor methods, commonly known as getters, allow access to the values of private attributes. They retrieve and return the value of an attribute without directly exposing the attribute itself.\n",
    "-> Controlled Read Access: By using getters, you control how external code retrieves the values of attributes. This enables additional logic or validation to be applied before returning the attribute's value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fbf75eaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.__name = name\n",
    "\n",
    "    def get_name(self):\n",
    "        return self.__name\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4fe882ea",
   "metadata": {},
   "source": [
    "2) Mutators (Setters):\n",
    "-> Purpose: Mutator methods, commonly known as setters, allow modification of the values of private attributes. They provide a controlled way to modify the internal state of an object by applying rules or validations before assigning new values.\n",
    "-> Controlled Write Access: Setters enable controlled modification of attribute values, allowing you to implement checks or constraints before updating the attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2b6b6f95",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BankAccount:\n",
    "    def __init__(self, balance):\n",
    "        self.__balance = balance\n",
    "\n",
    "    def set_balance(self, new_balance):\n",
    "        if new_balance >= 0:\n",
    "            self.__balance = new_balance\n",
    "        else:\n",
    "            print(\"Invalid balance value\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "595bd260",
   "metadata": {},
   "source": [
    "#### 16. What are the potential drawbacks or disadvantages of using encapsulation in Python?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "6316bd35",
   "metadata": {},
   "source": [
    "*) While encapsulation is a fundamental principle in object-oriented programming that offers numerous benefits, there are certain potential drawbacks or considerations to be mindful of when using encapsulation in Python:\n",
    "\n",
    "1) Complexity Overhead: Implementing encapsulation with getters, setters, or property decorators can lead to increased complexity in the codebase. It may require writing additional lines of code for access control, which could potentially affect code readability and increase development time.\n",
    "\n",
    "2) Performance Impact: Using getters and setters might introduce a slight performance overhead compared to directly accessing attributes. However, in Python, the performance impact is generally negligible, especially with the use of optimized techniques like property decorators.\n",
    "\n",
    "3) Verbose Code: Encapsulation, especially when strictly adhering to access control principles, can result in more verbose code. The need to define separate getter and setter methods for each attribute could make the code harder to read and maintain.\n",
    "\n",
    "4) Potential Misuse: Encapsulation doesn't prevent all forms of direct access to private attributes. Python doesn’t strictly enforce access control, so there's still a chance of direct access to private attributes using name mangling or other methods, leading to potential misuse.\n",
    "\n",
    "5) Restrictive Nature: Over-encapsulation can sometimes lead to a restrictive design, making it challenging for subclasses or external code to extend or modify the behavior of a class. It might limit flexibility and hinder the evolution of the codebase.\n",
    "\n",
    "6) Increased Indirection: By using getters and setters instead of direct attribute access, you add an additional layer of indirection. While this can provide better control and validation, it might also complicate code navigation and understanding for developers new to the codebase.\n",
    "\n",
    "7) Maintenance Overhead: When changes are needed in the internal representation of an object due to encapsulation, it may require modifications not only within the class but also across multiple areas of the codebase where the class is used. This could increase maintenance efforts.\n",
    "\n",
    "8) Complex Debugging: Encapsulation can sometimes make debugging more complex, especially if the internal state of an object is hidden and debugging information is not easily accessible from external code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d777b954",
   "metadata": {},
   "source": [
    "#### 17. Create a Python class for a library system that encapsulates book information, including titles, authors, and availability status.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "873ffd50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book Title: Python Programming\n",
      "Author: Thakkar Mit\n",
      "Is Available? True\n",
      "The book 'Python Programming' by Thakkar Mit has been borrowed.\n",
      "Is Available? False\n",
      "The book 'Python Programming' by Thakkar Mit has been returned.\n",
      "Is Available? True\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author):\n",
    "        self.__title = title\n",
    "        self.__author = author\n",
    "        self.__is_available = True  # Assuming all books are initially available\n",
    "\n",
    "    def get_title(self):\n",
    "        return self.__title\n",
    "\n",
    "    def get_author(self):\n",
    "        return self.__author\n",
    "\n",
    "    def check_availability(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, '{self.__title}' is currently unavailable.\")\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.\")\n",
    "\n",
    "# Example usage:\n",
    "book1 = Book(\"Python Programming\", \"Thakkar Mit\")\n",
    "\n",
    "print(\"Book Title:\", book1.get_title())\n",
    "print(\"Author:\", book1.get_author())\n",
    "print(\"Is Available?\", book1.check_availability())\n",
    "\n",
    "book1.borrow_book()\n",
    "print(\"Is Available?\", book1.check_availability())\n",
    "\n",
    "book1.return_book()\n",
    "print(\"Is Available?\", book1.check_availability())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17cbce10",
   "metadata": {},
   "source": [
    "#### 18. Explain how encapsulation enhances code reusability and modularity in Python programs.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "7450d410",
   "metadata": {},
   "source": [
    "Encapsulation plays a significant role in enhancing code reusability and modularity in Python programs through several mechanisms:\n",
    "\n",
    "1) Black Box Concept:\n",
    "-> Encapsulation allows the internal workings of an object to be hidden from the outside world.\n",
    "-> By exposing only a well-defined interface, encapsulation treats the object as a 'Black Box' \n",
    "-> users of the object only need to understand how to interact with it through its interface, not its internal implementation details\n",
    "-> this abstraction promotes code reusability as the object can be reused withhout needing to understand its interrnal complexities \n",
    "\n",
    "2) Modularity: \n",
    "-> Encapsulation promotes modularity by organizing code into smaller, manageable units\n",
    "-> Each class encapsulates its own attributs and methods, representing a modular component that can be reused in diferent parts of the program or in other programs altogether\n",
    "-> this modular approach makes the codebase more maintainable and facilitates easier updates or modifications to individual components without affecting the rest of the system\n",
    "\n",
    "3) Code Separation:\n",
    "-> Encapsulation separates the concerns of different components within a program\n",
    "-> each class represents a distinct entity with its own behavior and attributes \n",
    "-> this separation of concerns allows for cleaner code, where each class focuses on a specific functionality or data structure, making it easier to comprehend, reuse and maintain \n",
    "\n",
    "4) Inheritance and Composition:\n",
    "-> Encapsulation enables inheritance and composition, two key principles of object-oriented programming that contributes to code reuse\n",
    "-> Inheritance allows classes to inherit attributes and behaviors from other classes, promoting reuse of existing functionality.\n",
    "-> Composition allows classes to contain instance of other classes.\n",
    "-> This encapsulation shields other parts of the program from the complexity, allowing for simpler interactions and reuse of these components.\n",
    "\n",
    "5) Encapsulation of complexity \n",
    "-> By Encapulating complexity within classes, the overall codebase becomes more manageable\n",
    "-> Complex funcionalities or algorithms can be encapsulated into well-defined classes, abstracting away their intricacies.\n",
    "-> This encapsulation shields other parts of the program from the complexity, allowing for simpler interactions and reuse of these components "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03a1f03a",
   "metadata": {},
   "source": [
    "#### 19. Describe the concept of information hiding in encapsulation. Why is it essential in software development?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "542b92f2",
   "metadata": {},
   "source": [
    "-> Information hiding is a fundamental concept within encapsulation that involves concealing the internal details of how an object or module is implemented and exposing only the necessary or intended functionalities through a well-defined interface. It focuses on hiding the complexities and implementation details, revealing only what is necessary for external use.\n",
    "\n",
    "1) Abstraction: Information hiding provides an abstraction layer, allowing users of an object or module to interact with it without needing to know the intricate details of its internal workings. This abstraction simplifies complex systems, making them more understandable and usable.\n",
    "\n",
    "2) Reduced Complexity: By hiding unnecessary implementation details, information hiding reduces complexity, making the codebase more manageable and less prone to errors. Users can interact with the system through a clear and simplified interface.\n",
    "\n",
    "3) Enhanced Security: Critical internal details can be hidden, preventing unauthorized access or modification of sensitive data or functionality. It limits access to only the necessary interfaces, reducing security vulnerabilities.\n",
    "\n",
    "4) Improved Maintainability: Encapsulation with information hiding allows for changes to the internal implementation without affecting the external interface. This separation between the internal workings and the public interface enables easier maintenance and updates to the codebase.\n",
    "\n",
    "5) Encourages Modularity: Information hiding encourages modular design, enabling individual components to function independently. Modules or classes can be developed, tested, and maintained separately, promoting code reuse and scalability.\n",
    "\n",
    "6) Facilitates Team Collaboration: When multiple developers work on a project, information hiding aids in managing complexity. It allows developers to work on different parts of the system simultaneously without needing to understand the internal details of each other's components, as long as the defined interfaces are adhered to.\n",
    "\n",
    "7) Adaptable Design: Information hiding allows for changes to the internal implementation without affecting users of the system. This adaptability is crucial as it enables future enhancements, optimizations, or refactoring while maintaining compatibility with existing code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce6e5905",
   "metadata": {},
   "source": [
    "\n",
    "#### 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": 10,
   "id": "ee3b1430",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Customer Name: Alice\n",
      "Customer Address: 123 Main St\n",
      "Customer Contact: alice@example.com\n",
      "Address updated successfully\n",
      "Contact information updated successfully\n",
      "Updated Customer Address: 456 Oak Ave\n",
      "Updated Customer Contact: alice.updated@example.com\n"
     ]
    }
   ],
   "source": [
    "class Customer:\n",
    "    def __init__(self, name, address, contact):\n",
    "        self.__name = name\n",
    "        self.__address = address\n",
    "        self.__contact = contact\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(self):\n",
    "        return self.__contact\n",
    "\n",
    "    def update_address(self, new_address):\n",
    "        self.__address = new_address\n",
    "        print(\"Address updated successfully\")\n",
    "\n",
    "    def update_contact(self, new_contact):\n",
    "        self.__contact = new_contact\n",
    "        print(\"Contact information updated successfully\")\n",
    "\n",
    "# Example usage:\n",
    "customer = Customer(\"Alice\", \"123 Main St\", \"alice@example.com\")\n",
    "\n",
    "print(\"Customer Name:\", customer.get_name())\n",
    "print(\"Customer Address:\", customer.get_address())\n",
    "print(\"Customer Contact:\", customer.get_contact())\n",
    "\n",
    "# Updating customer information\n",
    "customer.update_address(\"456 Oak Ave\")\n",
    "customer.update_contact(\"alice.updated@example.com\")\n",
    "\n",
    "print(\"Updated Customer Address:\", customer.get_address())\n",
    "print(\"Updated Customer Contact:\", customer.get_contact())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b01de0ed",
   "metadata": {},
   "source": [
    "# Polymorphism:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c3361e7",
   "metadata": {},
   "source": [
    "#### 1. What is polymorphism in Python? Explain how it is related to object-oriented programming.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b005a157",
   "metadata": {},
   "source": [
    "-> Polymorphism, in the context of object-oriented programming (OOP), refers to the ability of different classes to be treated as objects of a common superclass. It allows objects of different classes to be treated uniformly if they share a common interface, allowing for more flexible and reusable code."
   ]
  },
  {
   "cell_type": "raw",
   "id": "bb06a77f",
   "metadata": {},
   "source": [
    "-> Polymorphism is one of the core principles of OOP, alongside encapsulation, inheritance, and abstraction. It allows for flexibility and extensibility in code by enabling classes that inherit from a common superclass to be used interchangeably. This concept is expressed through inheritance and method overriding.\n",
    "\n",
    "-> In Python, polymorphism is closely related to inheritance. When a subclass inherits from a superclass, it can provide its own implementation of methods defined in the superclass. This allows objects of different classes to be treated uniformly when they share a common interface (method signature) through inheritanc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "201c6921",
   "metadata": {},
   "source": [
    "#### 2. Describe the difference between compile-time polymorphism and runtime polymorphism in Python.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ce359cf7",
   "metadata": {},
   "source": [
    "-> Compile-Time Polymorphism (Method Overloading): In some languages (not Python), you can define multiple methods with the same name but different parameters within a class. This is known as method overloading. However, Python does not directly support method overloading based on different parameter types or numbers. Instead, you can achieve similar behavior using default arguments or variable-length arguments.\n",
    "\n",
    "-> Run-Time Polymorphism (Method Overriding): This type of polymorphism occurs when a method in a subclass has the same name and signature as a method in its superclass. The subclass method overrides the behavior of the superclass method, providing its own implementation. This is known as method overriding and is a common form of polymorphism used in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "063bda57",
   "metadata": {},
   "source": [
    "#### 3. Create a Python class hierarchy for shapes (e.g., circle, square, triangle) and demonstrate polymorphis through a common method, such as `calculate_area()`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e7cc89d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of Circle: 78.53981633974483\n",
      "Area of Square: 16\n",
      "Area of Triangle: 9.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "class Shape:\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 Square(Shape):\n",
    "    def __init__(self, side_length):\n",
    "        self.side_length = side_length\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return self.side_length ** 2\n",
    "\n",
    "class Triangle(Shape):\n",
    "    def __init__(self, base, height):\n",
    "        self.base = base\n",
    "        self.height = height\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return 0.5 * self.base * self.height\n",
    "\n",
    "# Example usage demonstrating polymorphism\n",
    "shapes = [Circle(5), Square(4), Triangle(3, 6)]\n",
    "\n",
    "for shape in shapes:\n",
    "    print(f\"Area of {type(shape).__name__}: {shape.calculate_area()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82760ddc",
   "metadata": {},
   "source": [
    "#### 4. Explain the concept of method overriding in polymorphism. Provide an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4b52c7a2",
   "metadata": {},
   "source": [
    "-> Method overriding is a concept in object-oriented programming that occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. The method in the subclass has the same name, parameters, and return type as the method in the superclass, effectively replacing the implementation inherited from the superclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ee25d6f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\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",
    "        print(\"Woof!\")  # Specific implementation for Dog\n",
    "\n",
    "class Cat(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Meow!\")  # Specific implementation for Cat\n",
    "\n",
    "# Example usage demonstrating method overriding\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "dog.make_sound()  # Outputs: Woof!\n",
    "cat.make_sound()  # Outputs: Meow!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5853138",
   "metadata": {},
   "source": [
    "#### 5. How is polymorphism different from method overloading in Python? Provide examples for both.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "f6d5497d",
   "metadata": {},
   "source": [
    "*) Polymorphism in Python:\n",
    "-> Polymorphism in Python refers to the ability of different classes to be treated as objects of a common superclass, allowing objects of different classes to be used interchangeably if they share a common interface (method name). This enables a single interface to be used for entities of different types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "48ce094b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def make_sound(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "class Cat(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Meow!\")\n",
    "\n",
    "def animal_sound(animal):\n",
    "    animal.make_sound()\n",
    "\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "animal_sound(dog)  # Outputs: Woof!\n",
    "animal_sound(cat)  # Outputs: Meow!\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "1f07db54",
   "metadata": {},
   "source": [
    "*) Method Overloading in Python:\n",
    "-> Traditional method overloading involves defining multiple methods with the same name but different parameter types or numbers within a class. In Python, method overloading is not directly supported as it is in languages like Java or C++. However, you can simulate a similar effect using default arguments or variable-length arguments (*args, **kwargs)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "53959fff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "class Calculator:\n",
    "    def add(self, a, b=None, c=None):\n",
    "        if b is None and c is None:\n",
    "            return a\n",
    "        elif c is None:\n",
    "            return a + b\n",
    "        else:\n",
    "            return a + b + c\n",
    "\n",
    "calc = Calculator()\n",
    "\n",
    "print(calc.add(5))        # Outputs: 5\n",
    "print(calc.add(2, 3))     # Outputs: 5\n",
    "print(calc.add(1, 2, 3))  # Outputs: 6\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "477b5146",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a3be76be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n",
      "Chirp!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def speak(self):\n",
    "        print(\"An unspecified animal makes a sound\")\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",
    "# Example demonstrating polymorphism\n",
    "animals = [Dog(), Cat(), Bird()]\n",
    "\n",
    "for animal in animals:\n",
    "    animal.speak()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dafbd8c",
   "metadata": {},
   "source": [
    "#### 7. Discuss the use of abstract methods and classes in achieving polymorphism in Python. Provide an example using the `abc` module.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d3b6fffb",
   "metadata": {},
   "source": [
    "-> In Python, abstract classes and methods provide a way to define a blueprint for classes, ensuring that specific methods are implemented in derived classes. The abc (Abstract Base Classes) module in Python allows you to create abstract classes and methods, enforcing the implementation of certain methods in subclasses. Abstract classes cannot be instantiated; they are meant to be subclassed to provide specific implementations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6d6039ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n",
      "Chirp!\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Animal(ABC):  # Abstract base class\n",
    "    @abstractmethod\n",
    "    def speak(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Woof!\")  # Specific implementation for Dog\n",
    "\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Meow!\")  # Specific implementation for Cat\n",
    "\n",
    "class Bird(Animal):\n",
    "    def speak(self):\n",
    "        print(\"Chirp!\")  # Specific implementation for Bird\n",
    "\n",
    "# Example demonstrating polymorphism\n",
    "animals = [Dog(), Cat(), Bird()]\n",
    "\n",
    "for animal in animals:\n",
    "    animal.speak()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "320fa45a",
   "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": 17,
   "id": "ce13665d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car started. Vroom!\n",
      "Bicycle started. Pedal!\n",
      "Boat started. Engine running!\n"
     ]
    }
   ],
   "source": [
    "class Vehicle:\n",
    "    def start(self):\n",
    "        pass\n",
    "\n",
    "class Car(Vehicle):\n",
    "    def start(self):\n",
    "        print(\"Car started. Vroom!\")\n",
    "\n",
    "class Bicycle(Vehicle):\n",
    "    def start(self):\n",
    "        print(\"Bicycle started. Pedal!\")\n",
    "\n",
    "class Boat(Vehicle):\n",
    "    def start(self):\n",
    "        print(\"Boat started. Engine running!\")\n",
    "\n",
    "# Example demonstrating polymorphic behavior\n",
    "vehicles = [Car(), Bicycle(), Boat()]\n",
    "\n",
    "for vehicle in vehicles:\n",
    "    vehicle.start()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12d82e5a",
   "metadata": {},
   "source": [
    "#### 9. Explain the significance of the `isinstance()` and `issubclass()` functions in Python polymorphism.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ad95a6e7",
   "metadata": {},
   "source": [
    "-> The isinstance() and issubclass() functions in Python are essential tools when working with polymorphism, inheritance, and object-oriented programming. They allow you to check relationships between objects and classes, enabling you to write flexible and adaptable code.\n",
    "\n",
    "-> The isinstance() function checks if an object is an instance of a particular class or a subclass of that class. It helps determine the type of an object, especially when dealing with inheritance and polymorphism."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8d2369c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class Vehicle:\n",
    "    pass\n",
    "\n",
    "class Car(Vehicle):\n",
    "    pass\n",
    "\n",
    "car = Car()\n",
    "\n",
    "print(isinstance(car, Car))  # Outputs: True\n",
    "print(isinstance(car, Vehicle))  # Outputs: True\n",
    "print(isinstance(car, int))  # Outputs: False\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "61fe8309",
   "metadata": {},
   "source": [
    "-> The issubclass() function checks if a given class is a subclass of another class. It helps determine class relationships and inheritance hierarchies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "102b4a86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class Vehicle:\n",
    "    pass\n",
    "\n",
    "class Car(Vehicle):\n",
    "    pass\n",
    "\n",
    "class Bicycle(Vehicle):\n",
    "    pass\n",
    "\n",
    "print(issubclass(Car, Vehicle))  # Outputs: True\n",
    "print(issubclass(Bicycle, Vehicle))  # Outputs: True\n",
    "print(issubclass(Car, int))  # Outputs: False\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ace8fcb",
   "metadata": {},
   "source": [
    "#### 10. What is the role of the `@abstractmethod` decorator in achieving polymorphism in Python? Provide an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "786a4bb4",
   "metadata": {},
   "source": [
    "-> The @abstractmethod decorator from the abc (Abstract Base Classes) module in Python plays a crucial role in achieving polymorphism by defining abstract methods in abstract base classes. Abstract methods serve as placeholders that must be implemented by subclasses, ensuring that classes adhering to the interface share a common method signature while providing specific implementations. This enforces a contract that all subclasses must follow, promoting polymorphic behavior across different subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c4ad7b23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n",
      "Chirp!\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Animal(ABC):\n",
    "    @abstractmethod\n",
    "    def make_sound(self):\n",
    "        pass\n",
    "\n",
    "class Dog(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Woof!\")  # Specific implementation for Dog\n",
    "\n",
    "class Cat(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Meow!\")  # Specific implementation for Cat\n",
    "\n",
    "class Bird(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Chirp!\")  # Specific implementation for Bird\n",
    "\n",
    "# Example demonstrating polymorphic behavior\n",
    "animals = [Dog(), Cat(), Bird()]\n",
    "\n",
    "for animal in animals:\n",
    "    animal.make_sound()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "342e486c",
   "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": 23,
   "id": "aae58cd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of Circle: 78.53981633974483\n",
      "Area of Rectangle: 24\n",
      "Area of Triangle: 7.5\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "class Shape:\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 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 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",
    "# Example demonstrating polymorphic behavior\n",
    "shapes = [Circle(5), Rectangle(4, 6), Triangle(3, 5)]\n",
    "\n",
    "for shape in shapes:\n",
    "    print(f\"Area of {type(shape).__name__}: {shape.area()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6f99f11",
   "metadata": {},
   "source": [
    "#### 12. Discuss the benefits of polymorphism in terms of code reusability and flexibility in Python programs.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "20143d26",
   "metadata": {},
   "source": [
    "*) Reusability of Code:\n",
    "-> Interface Uniformity: Polymorphism allows different classes to share a common interface, enabling code to interact with objects of various types through a consistent interface. This fosters code reusability by promoting a shared behavior across different objects.\n",
    "-> Diverse Implementations: Classes implementing a common interface can have unique implementations of methods. This allows for multiple implementations of the same method, improving code reuse without duplicating functionality.\n",
    "\n",
    "*) Flexibility and Extensibility:\n",
    "-> Adaptable Design: Polymorphism enables developers to create code that can work with different types of objects. This adaptability is essential for building flexible systems capable of handling various data structures or functionalities.\n",
    "-> Ease of Extension: As new classes adhere to the same interface, it's straightforward to extend the application by adding new classes without modifying existing code. This follows the Open/Closed Principle, promoting code that's open for extension but closed for modification."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19d2a2e3",
   "metadata": {},
   "source": [
    "#### 13. Explain the use of the `super()` function in Python polymorphism. How does it help call methods of parent classes?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "189a220b",
   "metadata": {},
   "source": [
    "-> The super() function in Python is used to access methods and properties of a parent or superclass within a subclass. It facilitates calling methods and accessing attributes defined in the superclass, enabling a form of cooperative multiple inheritance and ensuring that all classes in the inheritance chain are properly initialized.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "65570775",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generic animal sound\n",
      "Woof!\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 from the parent class\n",
    "        print(\"Woof!\")  # Extend the behavior of make_sound() in Dog\n",
    "\n",
    "dog = Dog()\n",
    "dog.make_sound()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36410b95",
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "33c86485",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Withdrawn $500 from Savings Account. Remaining balance: $500\n",
      "Withdrawn $500 from Checking Account. Remaining balance: $1500\n",
      "Withdrawn $500 from Credit Card Account. Remaining balance: $4500\n"
     ]
    }
   ],
   "source": [
    "class Account:\n",
    "    def __init__(self, account_number, balance):\n",
    "        self.account_number = account_number\n",
    "        self.balance = balance\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        pass\n",
    "\n",
    "class SavingsAccount(Account):\n",
    "    def withdraw(self, amount):\n",
    "        if amount <= self.balance:\n",
    "            self.balance -= amount\n",
    "            print(f\"Withdrawn ${amount} from Savings Account. Remaining balance: ${self.balance}\")\n",
    "        else:\n",
    "            print(\"Insufficient funds for withdrawal.\")\n",
    "\n",
    "class CheckingAccount(Account):\n",
    "    def withdraw(self, amount):\n",
    "        if amount <= self.balance:\n",
    "            self.balance -= amount\n",
    "            print(f\"Withdrawn ${amount} from Checking Account. Remaining balance: ${self.balance}\")\n",
    "        else:\n",
    "            print(\"Insufficient funds for withdrawal.\")\n",
    "\n",
    "class CreditCardAccount(Account):\n",
    "    def withdraw(self, amount):\n",
    "        # For simplicity, credit card allows unlimited withdrawal\n",
    "        self.balance -= amount\n",
    "        print(f\"Withdrawn ${amount} from Credit Card Account. Remaining balance: ${self.balance}\")\n",
    "\n",
    "# Example demonstrating polymorphic behavior\n",
    "savings = SavingsAccount(\"SAV123\", 1000)\n",
    "checking = CheckingAccount(\"CHK456\", 2000)\n",
    "credit_card = CreditCardAccount(\"CC789\", 5000)\n",
    "\n",
    "accounts = [savings, checking, credit_card]\n",
    "\n",
    "for account in accounts:\n",
    "    account.withdraw(500)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "584a22bd",
   "metadata": {},
   "source": [
    "#### 15. Describe the concept of operator overloading in Python and how it relates to polymorphism. Provide examples using operators like `+` and `*`.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "e04eccb1",
   "metadata": {},
   "source": [
    "-> Operator overloading in Python refers to the ability to redefine how operators work for user-defined classes. It allows custom classes to define their behavior for built-in operators such as +, -, *, /, and more, enabling objects of those classes to use these operators with the same syntax as built-in types"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9bf1b411",
   "metadata": {},
   "source": [
    "-> In Python, operator overloading is achieved by defining special methods (also called magic methods or dunder methods) within a class that correspond to specific operators.\n",
    "-> For example, to define the behavior of the + operator for instances of a custom class, you can implement the __add__() method in that class."
   ]
  },
  {
   "cell_type": "raw",
   "id": "cba3d0f5",
   "metadata": {},
   "source": [
    "*) Relation to Polymorphism:\n",
    "-> Operator overloading contributes to polymorphism by enabling objects of different classes to use the same operator with different meanings or behavior, depending on their implementation of the corresponding magic method.\n",
    "-> This allows different classes to define how they react to the same operator, providing flexibility and allowing polymorphic behavior across classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1f3af88f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition: (3, 7)\n",
      "Multiplication: (4, 6)\n"
     ]
    }
   ],
   "source": [
    "class Vector:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __add__(self, other):  # Overloading the + operator\n",
    "        return Vector(self.x + other.x, self.y + other.y)\n",
    "\n",
    "    def __mul__(self, scalar):  # Overloading the * operator\n",
    "        return Vector(self.x * scalar, self.y * scalar)\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"({self.x}, {self.y})\"\n",
    "\n",
    "# Example demonstrating operator overloading\n",
    "v1 = Vector(2, 3)\n",
    "v2 = Vector(1, 4)\n",
    "\n",
    "result_add = v1 + v2  # Calls __add__() method\n",
    "result_mul = v1 * 2    # Calls __mul__() method\n",
    "\n",
    "print(f\"Addition: {result_add}\")  # Outputs: (3, 7)\n",
    "print(f\"Multiplication: {result_mul}\")  # Outputs: (4, 6)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7810afc",
   "metadata": {},
   "source": [
    "#### 16. What is dynamic polymorphism, and how is it achieved in Python?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "6bad94a3",
   "metadata": {},
   "source": [
    "-> Dynamic polymorphism, also known as runtime polymorphism, refers to the ability of a program to decide which method to invoke at runtime, based on the actual object that the method is called upon. This allows different classes to be treated through a common interface, enabling flexibility and adaptability in code execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "08277a12",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def make_sound(self):\n",
    "        print(\"Generic animal sound\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Woof!\")  # Specific implementation for Dog\n",
    "\n",
    "class Cat(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Meow!\")  # Specific implementation for Cat\n",
    "\n",
    "def animal_sound(animal):\n",
    "    animal.make_sound()  # Common interface method\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f5cebfaa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n",
      "Meow!\n"
     ]
    }
   ],
   "source": [
    "# Example demonstrating dynamic polymorphism\n",
    "dog = Dog()\n",
    "cat = Cat()\n",
    "\n",
    "animal_sound(dog)  # Outputs: Woof!\n",
    "animal_sound(cat)  # Outputs: Meow!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd09331c",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e86248fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mit's salary: $70000\n",
      "TMR's salary: $50000\n",
      "Mit Thakkar's salary: $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, technology):\n",
    "        super().__init__(name, salary)\n",
    "        self.technology = technology\n",
    "\n",
    "class Designer(Employee):\n",
    "    def __init__(self, name, salary, experience):\n",
    "        super().__init__(name, salary)\n",
    "        self.experience = experience\n",
    "\n",
    "    def calculate_salary(self):\n",
    "        # Designers get an additional bonus based on experience\n",
    "        return self.salary + (self.experience * 1000)\n",
    "\n",
    "# Example demonstrating polymorphic behavior\n",
    "manager = Manager(\"Mit\", 60000, 10000)\n",
    "developer = Developer(\"TMR\", 50000, \"Python\")\n",
    "designer = Designer(\"Mit Thakkar\", 55000, 5)\n",
    "\n",
    "employees = [manager, developer, designer]\n",
    "\n",
    "for employee in employees:\n",
    "    print(f\"{employee.name}'s salary: ${employee.calculate_salary()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7178e805",
   "metadata": {},
   "source": [
    "#### 18. Discuss the concept of function pointers and how they can be used to achieve polymorphism in Python.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c29994ca",
   "metadata": {},
   "source": [
    "-> n Python, function pointers aren't directly exposed as they are in some other programming languages like C or C++. However, Python provides a mechanism called \"first-class functions,\" allowing functions to be passed around as arguments, returned from other functions, and assigned to variables. This feature enables achieving a form of polymorphism by dynamically selecting and invoking different functions based on the context."
   ]
  },
  {
   "cell_type": "raw",
   "id": "0a4ed907",
   "metadata": {},
   "source": [
    "1) Function Assignment to Variables:\n",
    "-> In Python, functions are objects, and they can be assigned to variables, allowing different functions to be stored in variables.\n",
    "\n",
    "2) Passing Functions as Arguments:\n",
    "-> Functions can be passed as arguments to other functions, allowing different behaviors to be injected into a function based on the function passed as an argument.\n",
    "\n",
    "3) Using Higher-Order Functions:\n",
    "-> Higher-order functions can accept other functions as parameters or return functions as results. These functions can be used to implement polymorphic behavior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "4616b862",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n",
      "Hola!\n",
      "Bonjour!\n"
     ]
    }
   ],
   "source": [
    "# Functions defining different greetings\n",
    "def greet_in_english():\n",
    "    return \"Hello!\"\n",
    "\n",
    "def greet_in_spanish():\n",
    "    return \"Hola!\"\n",
    "\n",
    "def greet_in_french():\n",
    "    return \"Bonjour!\"\n",
    "\n",
    "# A function that accepts and executes another function\n",
    "def greet(language_function):\n",
    "    return language_function()\n",
    "\n",
    "# Example demonstrating function-based polymorphism\n",
    "print(greet(greet_in_english))  # Outputs: Hello!\n",
    "print(greet(greet_in_spanish))  # Outputs: Hola!\n",
    "print(greet(greet_in_french))  # Outputs: Bonjour!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "561b61ad",
   "metadata": {},
   "source": [
    "#### 19. Explain the role of interfaces and abstract classes in polymorphism, drawing comparisons between them.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "31b20be8",
   "metadata": {},
   "source": [
    "-> In the context of polymorphism, both interfaces and abstract classes serve as tools for defining a commmon structure or contract that classes an adhere to\n",
    "-> they enable the creation of a common interface that multiple classes can implement, allowing specific implementations in each class\n",
    "-> However, They have differences in their implementation and usage "
   ]
  },
  {
   "cell_type": "raw",
   "id": "a546f1a0",
   "metadata": {},
   "source": [
    "*) Interfaces\n",
    "-> In python, interfaces are not explicitly defined as a language consturct but they can be emulated using abstract classes with no implementation or using protocols. \n",
    "-> An interface defines a set of methods that a class must implement without providing any implemenatation details. it establisjes a contrct for classes ensuring that they have specific methods but leaving the implementation up to the individual classes "
   ]
  },
  {
   "cell_type": "raw",
   "id": "99a2c127",
   "metadata": {},
   "source": [
    "*) Abstract Class\n",
    "-> Abstract classes are classes that cannot be instantiated on their own and may contain abstract methods that subclasses must override \n",
    "-> an abstract class provide a partial implementation and defines one or more abstract methods that must be implemented by its subsclasses\n",
    "-> it can also provide concrete methods that can be inherited by subclasses "
   ]
  },
  {
   "cell_type": "raw",
   "id": "e3c156ab",
   "metadata": {},
   "source": [
    "Comparisions:\n",
    "\n",
    "1)Implementation:\n",
    "-> Interfaces typically contain no implementation, only method signatures.\n",
    "Abstract classes may contain both abstract methods and concrete methods with or without implementation.\n",
    "\n",
    "2) Multiple Inheritance:\n",
    "-> Python doesn't have a built-in interface keyword, but interfaces can be emulated using abstract classes or protocols.\n",
    "Abstract classes support inheritance and can serve as a base class for other classes, allowing for method inheritance.\n",
    "\n",
    "3) Flexibility:\n",
    "-> Interfaces provide a higher level of flexibility as a class can implement multiple interfaces.\n",
    "Abstract classes allow for a mix of abstract and concrete methods, providing some level of default behavior for subclasses.\n",
    "\n",
    "4)Enforcement:\n",
    "-> Interfaces enforce that implementing classes define specific methods without providing any implementation.\n",
    "Abstract classes may enforce some methods to be implemented but can also provide default implementations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5a6efad",
   "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": 32,
   "id": "db4f580e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lion: Mammal sound\n",
      "Lion: Mammal eating\n",
      "Lion: Mammal sleeping\n",
      "\n",
      "Parrot: Bird sound\n",
      "Parrot: Bird eating\n",
      "Parrot: Bird sleeping\n",
      "\n",
      "Snake: Reptile sound\n",
      "Snake: Reptile eating\n",
      "Snake: Reptile sleeping\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def make_sound(self):\n",
    "        pass\n",
    "\n",
    "    def eat(self):\n",
    "        pass\n",
    "\n",
    "    def sleep(self):\n",
    "        pass\n",
    "\n",
    "class Mammal(Animal):\n",
    "    def make_sound(self):\n",
    "        return \"Mammal sound\"\n",
    "\n",
    "    def eat(self):\n",
    "        return \"Mammal eating\"\n",
    "\n",
    "    def sleep(self):\n",
    "        return \"Mammal sleeping\"\n",
    "\n",
    "class Bird(Animal):\n",
    "    def make_sound(self):\n",
    "        return \"Bird sound\"\n",
    "\n",
    "    def eat(self):\n",
    "        return \"Bird eating\"\n",
    "\n",
    "    def sleep(self):\n",
    "        return \"Bird sleeping\"\n",
    "\n",
    "class Reptile(Animal):\n",
    "    def make_sound(self):\n",
    "        return \"Reptile sound\"\n",
    "\n",
    "    def eat(self):\n",
    "        return \"Reptile eating\"\n",
    "\n",
    "    def sleep(self):\n",
    "        return \"Reptile sleeping\"\n",
    "\n",
    "# Zoo simulation demonstrating polymorphic behavior\n",
    "def simulate_zoo(animals):\n",
    "    for animal in animals:\n",
    "        print(f\"{animal.name}: {animal.make_sound()}\")\n",
    "        print(f\"{animal.name}: {animal.eat()}\")\n",
    "        print(f\"{animal.name}: {animal.sleep()}\")\n",
    "        print(\"\")\n",
    "\n",
    "# Creating instances of different animal types\n",
    "lion = Mammal(\"Lion\")\n",
    "parrot = Bird(\"Parrot\")\n",
    "snake = Reptile(\"Snake\")\n",
    "\n",
    "# Simulating the zoo with different animals\n",
    "simulate_zoo([lion, parrot, snake])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31594fdd",
   "metadata": {},
   "source": [
    "# Abstraction:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edab25b6",
   "metadata": {},
   "source": [
    "#### 1. What is abstraction in Python, and how does it relate to object-oriented programming?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "000119c8",
   "metadata": {},
   "source": [
    "-> Abstraction in Python, as well as in object-oriented programming (OOP) in general, refers to the concept of hiding complex implementation details while exposing only the necessary functionalities or behaviors of an object or system. It allows focusing on what an object does rather than how it does it, emphasizing the essential features and ignoring the irrelevant details."
   ]
  },
  {
   "cell_type": "raw",
   "id": "a2885b85",
   "metadata": {},
   "source": [
    "*) Relationship to Object-Oriented Programming (OOP):\n",
    "\n",
    "-> Abstraction is one of the core principles of OOP alongside encapsulation, inheritance, and polymorphism. It helps in building complex systems by breaking them down into manageable and understandable parts.\n",
    "\n",
    "-> In OOP, classes and objects serve as a means of abstraction by allowing the representation of real-world entities with specific behaviors and attributes while hiding the internal complexities.\n",
    "\n",
    "-> Abstraction enables the creation of reusable and modular code by allowing different parts of a system to interact through a well-defined interface, regardless of the underlying implementation details"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58c61831",
   "metadata": {},
   "source": [
    "#### 2. Describe the benefits of abstraction in terms of code organization and complexity reduction.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b611776f",
   "metadata": {},
   "source": [
    "-> Abstraction in code organization offers several benefits, primarily aiding in reducing complexity, improving maintainability, enhancing reusability, and promoting a clearer understanding of the codebase:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "57770cf5",
   "metadata": {},
   "source": [
    "1. Reducing Complexity:\n",
    "-> Hiding Implementation Details: Abstraction allows developers to hide complex implementation details, focusing on the essential functionalities. This simplifies interactions between different parts of the system, reducing cognitive load.\n",
    "\n",
    "-> Modularization: Breaking down a system into manageable and modular components through abstraction helps in dealing with complexity by dividing it into smaller, more understandable units."
   ]
  },
  {
   "cell_type": "raw",
   "id": "cb3e7872",
   "metadata": {},
   "source": [
    "2. Improving Maintainability:\n",
    "-> Isolation of Changes: Abstracting complex functionalities into separate components allows for changes in one part of the code without affecting other parts. This isolation minimizes the impact of modifications, making the codebase more maintainable.\n",
    "\n",
    "-> Easier Debugging and Troubleshooting: Clear abstractions with well-defined interfaces make it easier to locate issues, as developers can focus on specific components without being overwhelmed by the entire system."
   ]
  },
  {
   "cell_type": "raw",
   "id": "5d14d3ff",
   "metadata": {},
   "source": [
    "3. Enhancing Reusability:\n",
    "-> Encouraging Modularity: Abstraction promotes a modular design, enabling the reuse of components in different parts of the system or even in other projects.\n",
    "\n",
    "-> Utilization of Interfaces: Well-defined interfaces or abstract classes facilitate the creation of components that adhere to a specific contract, making them interchangeable and reusable in various contexts."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30208187",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1660a187",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the circle: 78.53975\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",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return 3.14159 * self.radius ** 2\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "# Example usage of Shape, Circle, and Rectangle classes\n",
    "circle = Circle(5)\n",
    "rectangle = Rectangle(4, 6)\n",
    "\n",
    "print(f\"Area of the circle: {circle.calculate_area()}\")  # Outputs the area of the circle\n",
    "print(f\"Area of the rectangle: {rectangle.calculate_area()}\")  # Outputs the area of the rectangle\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fb2db0d",
   "metadata": {},
   "source": [
    "#### 4. Explain the concept of abstract classes in Python and how they are defined using the `abc` module. Provide an example.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ccc4d129",
   "metadata": {},
   "source": [
    "-> In Python, abstract classes are classes that cannot be instantiated on their own and are designed to serve as a blueprint for other classes. They may contain one or more abstract methods—methods without implementation—that must be implemented by subclasses. Abstract classes define a structure and interface that subclasses are required to follow.\n",
    "\n",
    "*) Defining Abstract Classes using the abc Module:\n",
    "-> The abc module in Python provides tools for working with abstract classes. The ABC (Abstract Base Class) class and the abstractmethod decorator are used to define abstract classes and methods, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "1221a7eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Can't instantiate abstract class Shape with abstract method calculate_area\n",
      "Area of the circle: 78.53975\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",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return 3.14159 * self.radius ** 2\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    def calculate_area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "# Attempting to create an instance of an abstract class will raise an error\n",
    "try:\n",
    "    shape = Shape()  # This will raise an error as Shape is an abstract class\n",
    "except Exception as e:\n",
    "    print(f\"Error: {e}\")\n",
    "\n",
    "# Creating instances of concrete classes (Circle and Rectangle) is allowed\n",
    "circle = Circle(5)\n",
    "rectangle = Rectangle(4, 6)\n",
    "\n",
    "print(f\"Area of the circle: {circle.calculate_area()}\")\n",
    "print(f\"Area of the rectangle: {rectangle.calculate_area()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a917e43",
   "metadata": {},
   "source": [
    "#### 5. How do abstract classes differ from regular classes in Python? Discuss their use cases.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "1c9783a3",
   "metadata": {},
   "source": [
    "Differences between Abstract and Regular Classes:\n",
    "\n",
    "1) Instantiation:\n",
    "-> Abstract Classes: Cannot be instantiated on their own. They exist to be inherited by subclasses, and instances of abstract classes cannot be created.\n",
    "Regular Classes: Can be instantiated directly to create objects. They may or may not have methods with implementations.\n",
    "Abstract Methods:\n",
    "\n",
    "2) Abstract Classes:\n",
    "-> Can contain one or more abstract methods defined using the @abstractmethod decorator from the abc module. These methods have no implementation in the abstract class and must be overridden in subclasses.\n",
    "Regular Classes: Can have all methods with implementations. Subclasses are not forced to override any methods."
   ]
  },
  {
   "cell_type": "raw",
   "id": "8b864a94",
   "metadata": {},
   "source": [
    "Use Cases for Abstract Classes:\n",
    "\n",
    "1) Defining Interfaces:\n",
    "Abstract classes are used to define interfaces or contracts that specify methods to be implemented by subclasses. They ensure that subclasses adhere to a certain structure or interface.\n",
    "\n",
    "2) Forcing Method Implementation:\n",
    "Abstract classes enforce the implementation of specific methods in subclasses, ensuring that subclasses provide necessary functionality. This promotes consistency and standardization in the behavior of subclasses.\n",
    "\n",
    "3) Sharing Common Functionality:\n",
    "Abstract classes can contain common functionalities or attributes shared by multiple subclasses. This allows for code reuse among related classes.\n",
    "\n",
    "4) Designing Frameworks or Libraries:\n",
    "Abstract classes are often used in frameworks or libraries to define common behaviors or functionalities that developers can build upon. For instance, in GUI frameworks where abstract classes define methods to handle events or rendering."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9608da2e",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "b5f9a885",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial balance: $0\n",
      "Deposited $1000. Current balance: $1000\n",
      "Withdrew $500. Current balance: $500\n",
      "Insufficient funds\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class BankAccount(ABC):\n",
    "    def __init__(self, account_number, account_holder):\n",
    "        self.account_number = account_number\n",
    "        self.account_holder = account_holder\n",
    "        self._balance = 0  # Private attribute to store the account balance\n",
    "\n",
    "    @abstractmethod\n",
    "    def deposit(self, amount):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def withdraw(self, amount):\n",
    "        pass\n",
    "\n",
    "    def get_balance(self):\n",
    "        return self._balance\n",
    "\n",
    "# Subclass implementing BankAccount\n",
    "class SavingsAccount(BankAccount):\n",
    "    def deposit(self, amount):\n",
    "        self._balance += amount\n",
    "        print(f\"Deposited ${amount}. Current balance: ${self._balance}\")\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if self._balance >= amount:\n",
    "            self._balance -= amount\n",
    "            print(f\"Withdrew ${amount}. Current balance: ${self._balance}\")\n",
    "        else:\n",
    "            print(\"Insufficient funds\")\n",
    "\n",
    "# Example usage\n",
    "savings = SavingsAccount(\"123456\", \"Alice\")\n",
    "print(f\"Initial balance: ${savings.get_balance()}\")\n",
    "\n",
    "savings.deposit(1000)\n",
    "savings.withdraw(500)\n",
    "savings.withdraw(700)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed8fd45f",
   "metadata": {},
   "source": [
    "#### 7. Discuss the concept of interface classes in Python and their role in achieving abstraction.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "6bd60834",
   "metadata": {},
   "source": [
    "-> In Python, interface classes are not a built-in language feature, but the concept of interfaces can be emulated using abstract classes from the abc module. An interface in object-oriented programming defines a contract or blueprint for a set of methods that classes must implement, without providing any implementation details. Interface classes play a crucial role in achieving abstraction by defining a common structure that multiple classes can adhere to"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5625c67f",
   "metadata": {},
   "source": [
    "Role of Interface Classes in Achieving Abstraction:\n",
    "\n",
    "1) Defining Method Signatures:\n",
    "Interface classes define method signatures without implementing those methods. They serve as a template specifying what methods a class must implement.\n",
    "\n",
    "2) Enforcing Method Implementation:\n",
    "Classes that inherit from an interface class are required to implement all the methods defined in the interface. This enforces a specific structure or behavior across multiple classes.\n",
    "\n",
    "3) Promoting Consistency:\n",
    "Interface classes promote consistency and standardization by ensuring that classes implementing the interface provide expected functionalities. This allows for uniformity in interactions with objects.\n",
    "\n",
    "4) Facilitating Interchangeability:\n",
    "When multiple classes adhere to the same interface, objects of these classes can be used interchangeably through the interface. This promotes polymorphic behavior and flexibility in the codebase."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cafd39cb",
   "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": 38,
   "id": "1d7b3beb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Buddy is eating bones.\n",
      "Buddy is sleeping in a cozy bed.\n",
      "Whiskers is eating fish.\n",
      "Whiskers is napping in the sunlight.\n",
      "Dumbo is munching on leaves.\n",
      "Dumbo is resting under a tree.\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# Abstract class for Animal\n",
    "class Animal(ABC):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    @abstractmethod\n",
    "    def eat(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def sleep(self):\n",
    "        pass\n",
    "\n",
    "# Subclasses of Animal\n",
    "class Dog(Animal):\n",
    "    def eat(self):\n",
    "        return f\"{self.name} is eating bones.\"\n",
    "\n",
    "    def sleep(self):\n",
    "        return f\"{self.name} is sleeping in a cozy bed.\"\n",
    "\n",
    "class Cat(Animal):\n",
    "    def eat(self):\n",
    "        return f\"{self.name} is eating fish.\"\n",
    "\n",
    "    def sleep(self):\n",
    "        return f\"{self.name} is napping in the sunlight.\"\n",
    "\n",
    "class Elephant(Animal):\n",
    "    def eat(self):\n",
    "        return f\"{self.name} is munching on leaves.\"\n",
    "\n",
    "    def sleep(self):\n",
    "        return f\"{self.name} is resting under a tree.\"\n",
    "\n",
    "# Creating instances and demonstrating common methods\n",
    "dog = Dog(\"Buddy\")\n",
    "cat = Cat(\"Whiskers\")\n",
    "elephant = Elephant(\"Dumbo\")\n",
    "\n",
    "print(dog.eat())\n",
    "print(dog.sleep())\n",
    "print(cat.eat())\n",
    "print(cat.sleep())\n",
    "print(elephant.eat())\n",
    "print(elephant.sleep())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "439ad122",
   "metadata": {},
   "source": [
    "#### 9. Explain the significance of encapsulation in achieving abstraction. Provide examples.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "ca122180",
   "metadata": {},
   "source": [
    "-> Encapsulation and abstraction are closely related concepts in object-oriented programming, with encapsulation playing a significant role in achieving abstraction. Encapsulation refers to the bundling of data (attributes) and methods (functions or behaviors) that operate on the data within a single unit, i.e., a class. It allows for the restriction of access to certain components of an object, promoting better control over the interaction with the object's internals."
   ]
  },
  {
   "cell_type": "raw",
   "id": "12e1b130",
   "metadata": {},
   "source": [
    "Significance of Encapsulation in Achieving Abstraction:\n",
    "\n",
    "1) Hiding Implementation Details:\n",
    "Encapsulation allows the internal implementation details of a class to be hidden from external code. This hides the complexity and intricacies of how data is stored or manipulated, promoting a simpler and more manageable external interface.\n",
    "\n",
    "2) Providing Abstraction Barrier:\n",
    "By exposing only necessary functionalities through well-defined interfaces (methods), encapsulation creates a barrier that separates the external view (public interface) from the internal implementation. Users interact with objects through this interface, abstracting away the complexities of the internal workings.\n",
    "\n",
    "3) Promoting Data Integrity:\n",
    "Encapsulation helps maintain data integrity by restricting direct access to data members. It allows data to be accessed and modified only through controlled methods (getters/setters), enabling validation or manipulation of data before it's accessed or modified.\n",
    "\n",
    "4) Supporting Code Maintenance and Evolution:\n",
    "Encapsulation makes it easier to update or modify the internal workings of a class without affecting the external code that uses the class. Changes made within the class's encapsulated structure won't impact the external code as long as the public interface remains unchanged."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0493b96",
   "metadata": {},
   "source": [
    "#### 10. What is the purpose of abstract methods, and how do they enforce abstraction in Python classes?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "7ffd071d",
   "metadata": {},
   "source": [
    "Abstract methods serve the purpose of defining a method signature without providing any implementation in an abstract class. They act as placeholders that must be overridden in subclasses, enforcing a specific structure or contract across multiple classes. In Python, abstract methods are used in abstract classes defined with the abc module to enforce a common interface that subclasses must adhere to."
   ]
  },
  {
   "cell_type": "raw",
   "id": "a6a8a0c8",
   "metadata": {},
   "source": [
    "Purpose of Abstract Methods:\n",
    "\n",
    "1) Defining a Contract:\n",
    "Abstract methods define a contract or blueprint for methods that subclasses must implement. They specify the method names and parameters that subclasses must provide, promoting consistency across related classes.\n",
    "\n",
    "2) Enforcing Method Implementation:\n",
    "Abstract methods in an abstract class serve as a requirement that subclasses must fulfill by implementing those methods. This ensures that subclasses provide the necessary functionalities, promoting a standardized behavior.\n",
    "\n",
    "3) Promoting Polymorphic Behavior:\n",
    "By enforcing a common structure across multiple classes, abstract methods facilitate polymorphic behavior. Objects of different subclasses can be used interchangeably through their shared abstract methods."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efd17f67",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "80046478",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Toyota Corolla starts the engine.\n",
      "Toyota Corolla stops the engine.\n",
      "Harley-Davidson Sportster fires up.\n",
      "Harley-Davidson Sportster shuts down.\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Vehicle(ABC):\n",
    "    def __init__(self, brand, model):\n",
    "        self.brand = brand\n",
    "        self.model = model\n",
    "\n",
    "    @abstractmethod\n",
    "    def start(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def stop(self):\n",
    "        pass\n",
    "\n",
    "class Car(Vehicle):\n",
    "    def start(self):\n",
    "        return f\"{self.brand} {self.model} starts the engine.\"\n",
    "\n",
    "    def stop(self):\n",
    "        return f\"{self.brand} {self.model} stops the engine.\"\n",
    "\n",
    "class Motorcycle(Vehicle):\n",
    "    def start(self):\n",
    "        return f\"{self.brand} {self.model} fires up.\"\n",
    "\n",
    "    def stop(self):\n",
    "        return f\"{self.brand} {self.model} shuts down.\"\n",
    "\n",
    "car = Car(\"Toyota\", \"Corolla\")\n",
    "motorcycle = Motorcycle(\"Harley-Davidson\", \"Sportster\")\n",
    "\n",
    "print(car.start())\n",
    "print(car.stop())\n",
    "\n",
    "print(motorcycle.start())\n",
    "print(motorcycle.stop())\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3f25021",
   "metadata": {},
   "source": [
    "#### 12. Describe the use of abstract properties in Python and how they can be employed in abstract classes.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "60c3563f",
   "metadata": {},
   "source": [
    "Abstract properties in Python allow the definition of properties in abstract classes without providing an implementation for their getter and setter methods. They enforce that subclasses must override these properties, ensuring the presence of certain attributes in subclasses while allowing flexibility in their implementation."
   ]
  },
  {
   "cell_type": "raw",
   "id": "2dfea81d",
   "metadata": {},
   "source": [
    "Use of Abstract Properties:\n",
    "\n",
    "1) Defining Property Structure:\n",
    "Abstract properties set a structure for attributes that subclasses must possess without defining their actual implementation. They provide a blueprint for the existence of certain attributes in subclasses.\n",
    "\n",
    "2) Enforcing Attribute Presence:\n",
    "By making properties abstract in an abstract class, subclasses are mandated to implement these properties, ensuring that the necessary attributes exist in all subclasses.\n",
    "\n",
    "3) Promoting a Consistent Interface:\n",
    "Abstract properties, like abstract methods, contribute to defining a common interface across subclasses, promoting a consistent structure while allowing flexibility in the implementation of specific attributes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "934c441b",
   "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": 41,
   "id": "b30216f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TMR's salary is $60000.\n",
      "Mit's salary is $6400.\n",
      "Alice's salary is $60000.\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\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",
    "class Manager(Employee):\n",
    "    def __init__(self, name, employee_id, salary):\n",
    "        super().__init__(name, employee_id)\n",
    "        self.salary = salary\n",
    "\n",
    "    def get_salary(self):\n",
    "        return f\"{self.name}'s salary is ${self.salary}.\"\n",
    "\n",
    "class Developer(Employee):\n",
    "    def __init__(self, name, employee_id, hourly_rate, hours_worked):\n",
    "        super().__init__(name, employee_id)\n",
    "        self.hourly_rate = hourly_rate\n",
    "        self.hours_worked = hours_worked\n",
    "\n",
    "    def get_salary(self):\n",
    "        return f\"{self.name}'s salary is ${self.hourly_rate * self.hours_worked}.\"\n",
    "\n",
    "class Designer(Employee):\n",
    "    def __init__(self, name, employee_id, base_salary, bonus):\n",
    "        super().__init__(name, employee_id)\n",
    "        self.base_salary = base_salary\n",
    "        self.bonus = bonus\n",
    "\n",
    "    def get_salary(self):\n",
    "        return f\"{self.name}'s salary is ${self.base_salary + self.bonus}.\"\n",
    "\n",
    "# Creating instances and demonstrating the common get_salary() method\n",
    "manager = Manager(\"TMR\", 101, 60000)\n",
    "developer = Developer(\"Mit\", 102, 40, 160)\n",
    "designer = Designer(\"Alice\", 103, 50000, 10000)\n",
    "\n",
    "print(manager.get_salary())\n",
    "print(developer.get_salary())\n",
    "print(designer.get_salary())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b643fa8",
   "metadata": {},
   "source": [
    "#### 14. Discuss the differences between abstract classes and concrete classes in Python, including their instantiation.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "109162bc",
   "metadata": {},
   "source": [
    "*) Abstract Classes:\n",
    "-> Cannot be instantiated directly using the Class() syntax.\n",
    "-> Attempting to create an instance of an abstract class will raise an error.\n",
    "-> They serve as templates or blueprints for subclasses and provide a structure that subclasses must follow.\n",
    "\n",
    "*) Concrete Classes:\n",
    "-> Can be instantiated directly using the Class() syntax.\n",
    "-> They allow the creation of objects with specific behaviors and functionalities defined within the class.\n",
    "-> Objects of concrete classes can be created and used in the codebase."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2eb8129d",
   "metadata": {},
   "source": [
    "#### 15. Explain the concept of abstract data types (ADTs) and their role in achieving abstraction in Python.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9c0fbac2",
   "metadata": {},
   "source": [
    "-> Abstract Data Types (ADTs) are a key concept in computer science and software engineering that focus on the logical description of data and operations on that data without specifying the implementation details. They define a set of operations and their behavior on data, allowing data structures to be used without knowing how they are implemented internally."
   ]
  },
  {
   "cell_type": "raw",
   "id": "7be38290",
   "metadata": {},
   "source": [
    "Role of ADTs in Achieving Abstraction:\n",
    "\n",
    "1) Data Encapsulation:\n",
    "-> ADTs encapsulate both data and the operations that can be performed on that data, providing a clear separation between the interface (operations) and the implementation.\n",
    "\n",
    "2) Promoting Modularity:\n",
    "-> They promote modular programming by allowing the usage of data structures without concerning the user about their underlying implementations. This separation enhances code maintainability.\n",
    "\n",
    "3) Hiding Implementation Details:\n",
    "-> ADTs hide the complexities of how data is stored or manipulated, providing a high-level view that abstracts away implementation details. Users interact with the ADT through a defined set of operations.\n",
    "\n",
    "4) Standardized Interface:\n",
    "-> They define a standardized interface consisting of operations that users can perform on the data structure, ensuring consistency and allowing different implementations to be interchanged seamlessly.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f825cb5",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "6feff41c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dell XPS laptop is powering on.\n",
      "Dell XPS laptop is shutting down.\n",
      "HP Pavilion desktop is booting up.\n",
      "HP Pavilion desktop is shutting down.\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Computer(ABC):\n",
    "    def __init__(self, brand, model):\n",
    "        self.brand = brand\n",
    "        self.model = model\n",
    "\n",
    "    @abstractmethod\n",
    "    def power_on(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def shutdown(self):\n",
    "        pass\n",
    "\n",
    "class Laptop(Computer):\n",
    "    def power_on(self):\n",
    "        return f\"{self.brand} {self.model} laptop is powering on.\"\n",
    "\n",
    "    def shutdown(self):\n",
    "        return f\"{self.brand} {self.model} laptop is shutting down.\"\n",
    "\n",
    "class Desktop(Computer):\n",
    "    def power_on(self):\n",
    "        return f\"{self.brand} {self.model} desktop is booting up.\"\n",
    "\n",
    "    def shutdown(self):\n",
    "        return f\"{self.brand} {self.model} desktop is shutting down.\"\n",
    "\n",
    "# Creating instances and demonstrating the common methods\n",
    "laptop = Laptop(\"Dell\", \"XPS\")\n",
    "desktop = Desktop(\"HP\", \"Pavilion\")\n",
    "\n",
    "print(laptop.power_on())\n",
    "print(laptop.shutdown())\n",
    "\n",
    "print(desktop.power_on())\n",
    "print(desktop.shutdown())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b192c11",
   "metadata": {},
   "source": [
    "#### 17. Discuss the benefits of using abstraction in large-scale software development projects.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "edf6dbae",
   "metadata": {},
   "source": [
    "Abstraction plays a pivotal role in large-scale software development projects, offering several benefits that enhance the efficiency, maintainability, and scalability of the software. Here are key advantages of using abstraction in such projects:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "16d181fd",
   "metadata": {},
   "source": [
    "1. Manage Complexity:\n",
    "Simplify Understanding: Abstraction hides unnecessary details, allowing developers to focus on high-level concepts without delving into intricate implementation specifics. This simplifies the understanding of the system's architecture and design.\n",
    "\n",
    "2. Encourage Modularity and Reusability:\n",
    "Promote Modular Design: Abstraction facilitates breaking down complex systems into smaller, more manageable modules. This modular structure allows components to be developed and maintained independently.\n",
    "Enhance Reusability: Abstract components can be reused across different parts of the system or in entirely different projects, reducing redundant code and promoting a DRY (Don't Repeat Yourself) approach.\n",
    "\n",
    "3. Facilitate Maintenance and Updates:\n",
    "Isolate Changes: Changes or updates in the system can be localized to specific abstract components without impacting the entire system. This isolation minimizes the ripple effect of modifications, making maintenance easier.\n",
    "Improve Evolvability: Abstraction enables a flexible design that adapts to changing requirements. It allows for easier additions or modifications, ensuring the system's longevity.\n",
    "\n",
    "4. Enhance Collaboration:\n",
    "Standardized Interface: Abstract components define clear interfaces, promoting collaboration among developers or teams. Different parts of the system can interact seamlessly through standardized interfaces, fostering team collaboration and integration.\n",
    "\n",
    "5. Increase Testability and Debugging:\n",
    "Facilitate Testing: Abstract components can be tested independently, improving the testing process by isolating units for testing purposes.\n",
    "Ease Debugging: Abstraction helps in pinpointing issues by compartmentalizing functionalities. Debugging becomes more focused on specific components rather than the entire system.\n",
    "\n",
    "6. Support High-Level Design and Architecture:\n",
    "Aid in High-Level Design: Abstraction assists in creating high-level designs and architecture by focusing on essential functionalities and relationships between components.\n",
    "Promote Scalability: Abstract designs allow for scalable systems, enabling the addition of new features or scaling up the system's capacity without major restructuring.\n",
    "\n",
    "7. Reduce Dependency:\n",
    "Minimize Dependency Chains: By encapsulating implementation details, abstraction helps minimize dependency chains between modules, reducing coupling and making the system more robust and adaptable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "240c4a3d",
   "metadata": {},
   "source": [
    "#### 18. Explain how abstraction enhances code reusability and modularity in Python programs.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4936f72f",
   "metadata": {},
   "source": [
    "Code Reusability:\n",
    "\n",
    "\n",
    "1) Encapsulation of Logic:\n",
    "Abstraction allows developers to encapsulate complex logic or functionalities within modules or classes, abstracting away the implementation details.\n",
    "\n",
    "2) Promotion of Generic Components:\n",
    "Abstract components, through interfaces or base classes, define standardized behaviors and operations without specifying implementation. These generic components can be reused across multiple parts of the codebase.\n",
    "\n",
    "3) Reduction of Redundancy:\n",
    "By providing reusable components, abstraction reduces redundant code. Common functionalities or algorithms can be abstracted into separate units and reused wherever needed.\n",
    "\n",
    "4) Inheritance and Interfaces:\n",
    "In Python, inheritance and interfaces achieved through abstract classes or interfaces (using the abc module) enable the creation of reusable templates. Subclasses or implementations can reuse methods and behaviors defined in abstract classes or interfaces.\n",
    "\n",
    "\n",
    "Modularity:\n",
    "\n",
    "1) Clear Separation of Concerns:\n",
    "Abstraction facilitates the separation of concerns by breaking down the codebase into smaller, manageable modules or classes, each responsible for specific functionalities. This separation enhances the code's maintainability and readability.\n",
    "\n",
    "2) Isolation of Components:\n",
    "Abstracting functionalities into separate modules or classes isolates their behaviors, allowing changes or updates to be made within these components without affecting the entire codebase.\n",
    "\n",
    "3) Promotion of Dependency Injection:\n",
    "Abstraction allows for the use of interfaces or abstract classes to define dependencies. This promotes the concept of dependency injection, enabling the substitution of components, facilitating testing, and making the code more modular and adaptable.\n",
    "\n",
    "4) Facilitation of Plug-and-Play:\n",
    "Abstract components with well-defined interfaces or base classes provide a plug-and-play mechanism. New components adhering to these interfaces can seamlessly replace or extend existing functionalities without major modifications.\n",
    "\n",
    "5) Support for Scalability:\n",
    "Modular code, facilitated by abstraction, supports the scalability of the system. New features or enhancements can be implemented as separate modules, reducing the impact on existing functionalities and promoting maintainability."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "284fc3d6",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "85e13d44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book 'Python Programming' by Guido van Rossum added to the library.\n",
      "Book 'Data Structures and Algorithms' by Cormen added to the library.\n",
      "Book 'Python Programming' borrowed successfully.\n",
      "Book 'Data Structures and Algorithms' borrowed successfully.\n",
      "Book 'Python Programming' returned successfully.\n",
      "Book 'Python Programming' borrowed successfully.\n",
      "Book 'Python Programming' returned successfully.\n",
      "Book 'Nonexistent Book' does not exist in the library.\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class LibrarySystem(ABC):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.books = {}  # Dictionary to store books with their availability\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",
    "class Library(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:\n",
    "            if self.books[book_title]['available']:\n",
    "                self.books[book_title]['available'] = False\n",
    "                print(f\"Book '{book_title}' borrowed successfully.\")\n",
    "            else:\n",
    "                print(f\"Book '{book_title}' is currently unavailable.\")\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:\n",
    "            if not self.books[book_title]['available']:\n",
    "                self.books[book_title]['available'] = True\n",
    "                print(f\"Book '{book_title}' returned successfully.\")\n",
    "            else:\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",
    "# Creating an instance of the Library class\n",
    "library = Library(\"My Library\")\n",
    "\n",
    "# Testing the library methods\n",
    "library.add_book(\"Python Programming\", \"Guido van Rossum\")\n",
    "library.add_book(\"Data Structures and Algorithms\", \"Cormen\")\n",
    "library.borrow_book(\"Python Programming\")\n",
    "library.borrow_book(\"Data Structures and Algorithms\")\n",
    "library.return_book(\"Python Programming\")\n",
    "library.borrow_book(\"Python Programming\")\n",
    "library.return_book(\"Python Programming\")\n",
    "library.return_book(\"Nonexistent Book\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e7b7590",
   "metadata": {},
   "source": [
    "#### 20. Describe the concept of method abstraction in Python and how it relates to polymorphism."
   ]
  },
  {
   "cell_type": "raw",
   "id": "b4d202f1",
   "metadata": {},
   "source": [
    "-> Method abstraction in Python refers to the process of defining a method in an abstract manner within a base class or interface, without providing its implementation details. This allows subclasses or implementing classes to override these methods with their own specific implementations.\n",
    "\n",
    "Relation to Polymorphism:\n",
    "\n",
    "1) Common Interface:\n",
    "Method abstraction ensures the definition of a common interface through abstract methods in an abstract base class or interface.\n",
    "\n",
    "2) Polymorphic Behavior:\n",
    "Subclasses or implementing classes override these abstract methods with their own implementations, allowing for polymorphic behavior.\n",
    "\n",
    "3) Runtime Binding:\n",
    "During runtime, the correct method implementation is selected based on the object's actual type, enabling polymorphic behavior.\n",
    "\n",
    "4) Dynamic Method Invocation:\n",
    "Polymorphism allows different objects to be treated uniformly, invoking the appropriate method based on their specific type at runtime."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2519c718",
   "metadata": {},
   "source": [
    "# Composition:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf8c3982",
   "metadata": {},
   "source": [
    "#### 1. Explain the concept of composition in Python and how it is used to build complex objects from simpler ones.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "cd73a763",
   "metadata": {},
   "source": [
    "-> Composition in Python refers to a design principle where complex objects are constructed by combining simpler or smaller objects, forming a \"has-a\" relationship between them. It involves creating new objects by using instances of other classes within them, allowing for the construction of more complex structures."
   ]
  },
  {
   "cell_type": "raw",
   "id": "e0f94bb9",
   "metadata": {},
   "source": [
    "Key Points about Composition:\n",
    "\n",
    "1) \"Has-a\" Relationship:\n",
    "Composition implies that an object contains other objects as part of its structure. For example, a car has an engine, wheels, and various components.\n",
    "\n",
    "2) Building Complex Objects:\n",
    "Complex objects are constructed by aggregating simpler objects as their parts, enabling the creation of intricate and interconnected structures.\n",
    "\n",
    "3) Code Reusability:\n",
    "Composition promotes code reusability by allowing the reuse of existing classes as components within larger structures, avoiding code duplication.\n",
    "\n",
    "4) Flexibility and Modularity:\n",
    "It promotes flexibility in design by allowing components to be swapped or replaced easily, enhancing modularity and maintainability."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e93fa61",
   "metadata": {},
   "source": [
    "#### 2. Describe the difference between composition and inheritance in object-oriented programming.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "493d24a6",
   "metadata": {},
   "source": [
    "1) Relationship:\n",
    "Composition establishes a \"has-a\" relationship between classes (object contains other objects).\n",
    "Inheritance establishes an \"is-a\" relationship (subclass is a type of superclass).\n",
    "\n",
    "2) Flexibility:\n",
    "Composition offers more flexibility as objects can contain various other objects.\n",
    "Inheritance provides a structured hierarchy but can lead to tighter coupling between classes.\n",
    "\n",
    "3) Modularity:\n",
    "Composition facilitates modularity by allowing parts to be interchanged more easily.\n",
    "Inheritance offers a hierarchical structure but might lead to a rigid class hierarchy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56d993ae",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "98bc0c0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book Title: Harry Potter and the Philosopher's Stone\n",
      "Author: J.K. Rowling\n",
      "Author Birthdate: July 31, 1965\n",
      "Published Year: 1997\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, published_year):\n",
    "        self.title = title\n",
    "        self.author = author  # Composition: Book has an Author\n",
    "        self.published_year = published_year\n",
    "\n",
    "# Creating an Author object\n",
    "author1 = Author(\"J.K. Rowling\", \"July 31, 1965\")\n",
    "\n",
    "# Creating a Book object that includes the Author object\n",
    "book1 = Book(\"Harry Potter and the Philosopher's Stone\", author1, 1997)\n",
    "\n",
    "# Accessing book details and author information\n",
    "print(f\"Book Title: {book1.title}\")\n",
    "print(f\"Author: {book1.author.name}\")\n",
    "print(f\"Author Birthdate: {book1.author.birthdate}\")\n",
    "print(f\"Published Year: {book1.published_year}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8522aaf",
   "metadata": {},
   "source": [
    "#### 4. Discuss the benefits of using composition over inheritance in Python, especially in terms of code flexibility and reusability.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "2f68be73",
   "metadata": {},
   "source": [
    "1. Flexibility:\n",
    "\n",
    "1) Less Coupling:\n",
    "Composition allows for looser coupling between classes, reducing dependencies. Objects can change independently without affecting each other.\n",
    "\n",
    "2) Dynamic Relationships:\n",
    "Objects can be composed dynamically at runtime, enabling the creation of different configurations of objects as needed.\n",
    "\n",
    "3) Multiple Components:\n",
    "Composition supports multiple components of the same type within a class, offering more flexibility in combining various elements.\n",
    "\n",
    "\n",
    "2. Code Reusability:\n",
    "\n",
    "1) Greater Flexibility in Reusing Code:\n",
    "Composition promotes code reuse by favoring aggregation of behavior over inheritance of behavior. This allows for easier reusability of individual components in different contexts.\n",
    "\n",
    "2) Enhanced Modularity:\n",
    "Components can be modified, replaced, or extended more easily without affecting the entire class structure, thus supporting modularity.\n",
    "\n",
    "\n",
    "3. Reduced Complexity:\n",
    "\n",
    "1) Avoiding Deep Inheritance Trees:\n",
    "Composition avoids creating deep inheritance trees, which can become complex and difficult to maintain. It simplifies class hierarchies, making code more understandable.\n",
    "\n",
    "2) Favoring Object Composition:\n",
    "Encouraging object composition over inheritance reduces the need for extensive inheritance chains, mitigating the issues related to method overriding and multiple levels of abstraction.\n",
    "\n",
    "\n",
    "4. Adaptability and Maintainability:\n",
    "\n",
    "1) Easier to Modify and Extend:\n",
    "Components can be added, removed, or replaced without impacting other parts of the code, making the system more adaptable and maintainable.\n",
    "\n",
    "2) Reduced Side Effects:\n",
    "Changes in one component do not lead to cascading changes in other classes, reducing unintended side effects in the codebase.\n",
    "Example:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e5b6663",
   "metadata": {},
   "source": [
    "#### 5. How can you implement composition in Python classes? Provide examples of using composition to create complex objects.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "e6458f5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CPU:\n",
    "    def __init__(self, model):\n",
    "        self.model = model\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"CPU Model: {self.model}\"\n",
    "\n",
    "class RAM:\n",
    "    def __init__(self, size_gb):\n",
    "        self.size_gb = size_gb\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"RAM Size: {self.size_gb}GB\"\n",
    "\n",
    "class Computer:\n",
    "    def __init__(self, cpu, ram):\n",
    "        self.cpu = cpu  # Composition: Computer has a CPU\n",
    "        self.ram = ram  # Composition: Computer has RAM\n",
    "\n",
    "    def get_specs(self):\n",
    "        return f\"Computer Specs:\\n{self.cpu.get_info()}\\n{self.ram.get_info()}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "4e42cb60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computer Specs:\n",
      "CPU Model: Intel i7\n",
      "RAM Size: 16GB\n"
     ]
    }
   ],
   "source": [
    "# Creating instances of CPU and RAM\n",
    "my_cpu = CPU(\"Intel i7\")\n",
    "my_ram = RAM(16)\n",
    "\n",
    "# Creating a Computer object by composing CPU and RAM instances\n",
    "my_computer = Computer(my_cpu, my_ram)\n",
    "\n",
    "# Accessing computer specifications through composition\n",
    "print(my_computer.get_specs())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20935656",
   "metadata": {},
   "source": [
    "#### 6. Create a Python class hierarchy for a music player system, using composition to represent playlists and songs.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "819b75be",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Song:\n",
    "    def __init__(self, title, artist):\n",
    "        self.title = title\n",
    "        self.artist = artist\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"Title: {self.title} - Artist: {self.artist}\"\n",
    "\n",
    "\n",
    "class Playlist:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.songs = []  # List to store Song objects\n",
    "\n",
    "    def add_song(self, song):\n",
    "        self.songs.append(song)\n",
    "\n",
    "    def remove_song(self, song):\n",
    "        if song in self.songs:\n",
    "            self.songs.remove(song)\n",
    "\n",
    "    def list_songs(self):\n",
    "        if not self.songs:\n",
    "            return \"No songs in this playlist.\"\n",
    "        else:\n",
    "            return \"\\n\".join([song.get_info() for song in self.songs])\n",
    "\n",
    "\n",
    "class MusicPlayer:\n",
    "    def __init__(self):\n",
    "        self.playlists = {}  # Dictionary to store Playlist objects\n",
    "\n",
    "    def create_playlist(self, name):\n",
    "        self.playlists[name] = Playlist(name)\n",
    "\n",
    "    def add_song_to_playlist(self, playlist_name, song):\n",
    "        if playlist_name in self.playlists:\n",
    "            self.playlists[playlist_name].add_song(song)\n",
    "        else:\n",
    "            print(f\"Playlist '{playlist_name}' does not exist.\")\n",
    "\n",
    "    def remove_song_from_playlist(self, playlist_name, song):\n",
    "        if playlist_name in self.playlists:\n",
    "            self.playlists[playlist_name].remove_song(song)\n",
    "        else:\n",
    "            print(f\"Playlist '{playlist_name}' does not exist.\")\n",
    "\n",
    "    def list_songs_in_playlist(self, playlist_name):\n",
    "        if playlist_name in self.playlists:\n",
    "            return self.playlists[playlist_name].list_songs()\n",
    "        else:\n",
    "            return f\"Playlist '{playlist_name}' does not exist.\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "e384da35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Title: Song 1 - Artist: Artist A\n",
      "Title: Song 2 - Artist: Artist B\n",
      "No songs in this playlist.\n"
     ]
    }
   ],
   "source": [
    "# Creating a MusicPlayer instance\n",
    "my_player = MusicPlayer()\n",
    "\n",
    "# Creating songs\n",
    "song1 = Song(\"Song 1\", \"Artist A\")\n",
    "song2 = Song(\"Song 2\", \"Artist B\")\n",
    "\n",
    "# Creating playlists\n",
    "my_player.create_playlist(\"Favorites\")\n",
    "my_player.create_playlist(\"Party Mix\")\n",
    "\n",
    "# Adding songs to playlists\n",
    "my_player.add_song_to_playlist(\"Favorites\", song1)\n",
    "my_player.add_song_to_playlist(\"Party Mix\", song2)\n",
    "\n",
    "# Listing songs in playlists\n",
    "print(my_player.list_songs_in_playlist(\"Favorites\"))\n",
    "print(my_player.list_songs_in_playlist(\"Party Mix\"))\n",
    "\n",
    "# Removing a song from a playlist\n",
    "my_player.remove_song_from_playlist(\"Party Mix\", song2)\n",
    "print(my_player.list_songs_in_playlist(\"Party Mix\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cd32408",
   "metadata": {},
   "source": [
    "#### 7. Explain the concept of \"has-a\" relationships in composition and how it helps design software systems.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "8725543c",
   "metadata": {},
   "source": [
    "-> The concept of \"has-a\" relationships in composition refers to a design principle where one class (an object) contains or is composed of another class (another object) as a part or component. This relationship is established by including instances of other classes as attributes within a class, forming a structural dependency."
   ]
  },
  {
   "cell_type": "raw",
   "id": "4c87ab5d",
   "metadata": {},
   "source": [
    "1) Modularity and Encapsulation:\n",
    "Composition promotes modularity by encapsulating smaller objects within larger ones. Each object focuses on a specific responsibility, enhancing code organization and readability.\n",
    "\n",
    "2) Code Reusability:\n",
    "Objects can be reused as components in different contexts. This promotes code reuse, reducing redundancy and enhancing maintainability.\n",
    "\n",
    "3) Flexibility and Dynamic Relationships:\n",
    "Allows for dynamic relationships between objects at runtime. Objects can be composed or replaced dynamically, facilitating flexible configurations.\n",
    "\n",
    "4) Hierarchical Structures:\n",
    "Enables the creation of hierarchical structures, where objects at different levels of abstraction are composed to build complex systems.\n",
    "\n",
    "\n",
    "5) Loose Coupling and Independence:\n",
    "Reduces tight coupling between classes. Changes to one component don’t necessarily affect the entire system, promoting independence and minimizing side effects.\n",
    "\n",
    "6) Simplicity and Understanding:\n",
    "Simplifies complex systems by breaking them into smaller, more manageable components. This aids in better understanding and maintenance of the codebase."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f17cf457",
   "metadata": {},
   "source": [
    "#### 8. Create a Python class for a computer system, using composition to represent components like CPU, RAM, and storage devices.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "26d7b417",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CPU:\n",
    "    def __init__(self, model, cores):\n",
    "        self.model = model\n",
    "        self.cores = cores\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"CPU Model: {self.model}, Cores: {self.cores}\"\n",
    "\n",
    "class RAM:\n",
    "    def __init__(self, capacity_gb, speed):\n",
    "        self.capacity_gb = capacity_gb\n",
    "        self.speed = speed\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"RAM Capacity: {self.capacity_gb}GB, Speed: {self.speed}MHz\"\n",
    "\n",
    "class Storage:\n",
    "    def __init__(self, capacity_gb, type):\n",
    "        self.capacity_gb = capacity_gb\n",
    "        self.type = type\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"Storage Capacity: {self.capacity_gb}GB, Type: {self.type}\"\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 get_specs(self):\n",
    "        cpu_info = self.cpu.get_info()\n",
    "        ram_info = self.ram.get_info()\n",
    "        storage_info = self.storage.get_info()\n",
    "        return f\"Computer Specifications:\\n{cpu_info}\\n{ram_info}\\n{storage_info}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "cb7fb072",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computer Specifications:\n",
      "CPU Model: Intel Core i5, Cores: 4\n",
      "RAM Capacity: 8GB, Speed: 2400MHz\n",
      "Storage Capacity: 512GB, Type: SSD\n"
     ]
    }
   ],
   "source": [
    "# Creating instances for CPU, RAM, and Storage\n",
    "my_cpu = CPU(\"Intel Core i5\", 4)\n",
    "my_ram = RAM(8, 2400)\n",
    "my_storage = Storage(512, \"SSD\")\n",
    "\n",
    "# Creating a Computer object by composing CPU, RAM, and Storage instances\n",
    "my_computer = Computer(my_cpu, my_ram, my_storage)\n",
    "\n",
    "# Accessing computer specifications through composition\n",
    "print(my_computer.get_specs())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af20d152",
   "metadata": {},
   "source": [
    "#### 9. Describe the concept of \"delegation\" in composition and how it simplifies the design of complex systems.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4beb913c",
   "metadata": {},
   "source": [
    "-> \"Delegation\" in the context of composition refers to the process of passing responsibility for a particular task or behavior to another object. It allows an object to delegate certain functionalities to another object it contains, allowing for a more modular and flexible design."
   ]
  },
  {
   "cell_type": "raw",
   "id": "bdde0d9a",
   "metadata": {},
   "source": [
    "Key Points about Delegation in Composition:\n",
    "\n",
    "1) Task Delegation:\n",
    "Delegation involves assigning specific tasks or behaviors to other objects within a class hierarchy.\n",
    "\n",
    "2) Code Reuse:\n",
    "It promotes code reuse by utilizing existing functionalities implemented in other classes, avoiding redundancy and improving maintainability.\n",
    "\n",
    "3) Modular Design:\n",
    "Objects can focus on specific responsibilities, leading to a modular design where each object handles a distinct set of functionalities.\n",
    "\n",
    "4) Loose Coupling:\n",
    "Delegation reduces tight coupling between objects. Objects are more independent, making the system less prone to side effects when changes occur.\n",
    "\n",
    "5) Enhanced Flexibility:\n",
    "It allows for dynamic behavior, as objects can delegate tasks dynamically at runtime, enabling flexible configurations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95fa648e",
   "metadata": {},
   "source": [
    "#### 10. Create a Python class for a car, using composition to represent components like the engine, wheels, and transmission.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "15a92869",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Engine:\n",
    "    def start(self):\n",
    "        return \"Engine started.\"\n",
    "\n",
    "    def stop(self):\n",
    "        return \"Engine stopped.\"\n",
    "\n",
    "class Wheels:\n",
    "    def rotate(self):\n",
    "        return \"Wheels rotating.\"\n",
    "\n",
    "class Transmission:\n",
    "    def change_gear(self):\n",
    "        return \"Gear changed.\"\n",
    "\n",
    "class Car:\n",
    "    def __init__(self):\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_car(self):\n",
    "        return self.engine.start()\n",
    "\n",
    "    def stop_car(self):\n",
    "        return self.engine.stop()\n",
    "\n",
    "    def move(self):\n",
    "        return self.wheels.rotate()\n",
    "\n",
    "    def change_gear(self):\n",
    "        return self.transmission.change_gear()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "6b7514c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Engine started.\n",
      "Wheels rotating.\n",
      "Gear changed.\n",
      "Engine stopped.\n"
     ]
    }
   ],
   "source": [
    "my_car = Car()\n",
    "\n",
    "# Starting the car\n",
    "print(my_car.start_car())  # Output: \"Engine started.\"\n",
    "\n",
    "# Moving the car\n",
    "print(my_car.move())  # Output: \"Wheels rotating.\"\n",
    "\n",
    "# Changing gear\n",
    "print(my_car.change_gear())  # Output: \"Gear changed.\"\n",
    "\n",
    "# Stopping the car\n",
    "print(my_car.stop_car())  # Output: \"Engine stopped.\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "994fe6ba",
   "metadata": {},
   "source": [
    "#### 11. How can you encapsulate and hide the details of composed objects in Python classes to maintain abstraction?\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "5d0e3b57",
   "metadata": {},
   "source": [
    "-> In Python, you can encapsulate and hide the details of composed objects within a class to maintain abstraction by utilizing access modifiers, like private attributes, and providing controlled access to the composed objects."
   ]
  },
  {
   "cell_type": "raw",
   "id": "73dac28f",
   "metadata": {},
   "source": [
    "Techniques to Encapsulate Composed Objects:\n",
    "\n",
    "1) Private Attributes:\n",
    "Use private attributes to hide the details of composed objects. Prefixing an attribute with double underscores (__) makes it private, restricting direct access from outside the class.\n",
    "\n",
    "2) Getter and Setter Methods:\n",
    "Implement getter and setter methods to control access to the composed objects' attributes. This allows manipulation while maintaining encapsulation.\n",
    "\n",
    "3) Property Decorators:\n",
    "Utilize property decorators to create properties for accessing private attributes indirectly, providing more controlled access and allowing validation or modification upon access."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd957fe8",
   "metadata": {},
   "source": [
    "#### 12. Create a Python class for a university course, using composition to represent students, instructors, and course materials.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "b0ab5cc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self, name, student_id):\n",
    "        self.name = name\n",
    "        self.student_id = student_id\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"Student Name: {self.name}, ID: {self.student_id}\"\n",
    "\n",
    "class Instructor:\n",
    "    def __init__(self, name, instructor_id):\n",
    "        self.name = name\n",
    "        self.instructor_id = instructor_id\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"Instructor Name: {self.name}, ID: {self.instructor_id}\"\n",
    "\n",
    "class CourseMaterial:\n",
    "    def __init__(self, material_name):\n",
    "        self.material_name = material_name\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"Course Material: {self.material_name}\"\n",
    "\n",
    "class Course:\n",
    "    def __init__(self, course_name, instructor, students, materials):\n",
    "        self.course_name = course_name\n",
    "        self.instructor = instructor  # Composition: Course has an Instructor\n",
    "        self.students = students  # Composition: Course has a list of Students\n",
    "        self.materials = materials  # Composition: Course has Course Materials\n",
    "\n",
    "    def get_course_info(self):\n",
    "        instructor_info = self.instructor.get_info()\n",
    "        students_info = [student.get_info() for student in self.students]\n",
    "        materials_info = [material.get_info() for material in self.materials]\n",
    "\n",
    "        return f\"Course Name: {self.course_name}\\n\" \\\n",
    "               f\"Instructor Info: {instructor_info}\\n\" \\\n",
    "               f\"Students Info: {', '.join(students_info)}\\n\" \\\n",
    "               f\"Course Materials: {', '.join(materials_info)}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "2e1520c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Course Name: Python Programming\n",
      "Instructor Info: Instructor Name: Dr. Smith, ID: 201\n",
      "Students Info: Student Name: Alice, ID: 101, Student Name: Bob, ID: 102\n",
      "Course Materials: Course Material: Lecture Slides, Course Material: Textbook\n"
     ]
    }
   ],
   "source": [
    "# Creating students\n",
    "student1 = Student(\"Alice\", 101)\n",
    "student2 = Student(\"Bob\", 102)\n",
    "\n",
    "# Creating an instructor\n",
    "instructor = Instructor(\"Dr. Smith\", 201)\n",
    "\n",
    "# Creating course materials\n",
    "material1 = CourseMaterial(\"Lecture Slides\")\n",
    "material2 = CourseMaterial(\"Textbook\")\n",
    "\n",
    "# Creating a Course object by composing Instructor, Students, and Materials\n",
    "my_course = Course(\"Python Programming\", instructor, [student1, student2], [material1, material2])\n",
    "\n",
    "# Getting course information\n",
    "print(my_course.get_course_info())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84b5d1ed",
   "metadata": {},
   "source": [
    "#### 13. Discuss the challenges and drawbacks of composition, such as increased complexity and potential for tight coupling between objects.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "481f0fa2",
   "metadata": {},
   "source": [
    "hallenges and Drawbacks of Composition:\n",
    "    \n",
    "1) Increased Complexity:\n",
    "Composition can lead to increased complexity as the number of composed objects grows. Managing the interactions and dependencies between multiple components can become challenging.\n",
    "\n",
    "2) Tight Coupling:\n",
    "Overuse of composition can potentially lead to tight coupling between objects. If an object holds references to many other objects, changing one object might impact others, causing unintended side effects.\n",
    "\n",
    "3) Delegating Responsibilities:\n",
    "Designing classes that delegate responsibilities through composition requires careful consideration. It might become challenging to determine which object should be responsible for specific tasks.\n",
    "\n",
    "4) Maintenance Overhead:\n",
    "When a composed object changes, there could be a ripple effect on the containing object. This might increase maintenance overhead and make the system harder to maintain.\n",
    "\n",
    "5) Nested Complexity:\n",
    "Deeply nested compositions can lead to excessive levels of abstraction, making the codebase hard to comprehend, debug, and maintain.\n",
    "\n",
    "6) Granularity of Components:\n",
    "Determining the granularity of components can be challenging. Objects might end up too fine-grained, leading to an overabundance of small, interdependent objects.\n",
    "\n",
    "7) Performance Overhead:\n",
    "Excessive object composition might introduce performance overhead due to the creation and management of numerous objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc1128e9",
   "metadata": {},
   "source": [
    "#### 14. Create a Python class hierarchy for a restaurant system, using composition to represent menus, dishes, and ingredients.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "48bea0b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ingredient:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def get_info(self):\n",
    "        return 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 Ingredients\n",
    "\n",
    "    def get_info(self):\n",
    "        ingredients_info = [ingredient.get_info() for ingredient in self.ingredients]\n",
    "        return f\"Dish: {self.name} Ingredients: {', '.join(ingredients_info)}\"\n",
    "\n",
    "class Menu:\n",
    "    def __init__(self, name, dishes):\n",
    "        self.name = name\n",
    "        self.dishes = dishes  # Composition: Menu has Dishes\n",
    "\n",
    "    def get_info(self):\n",
    "        dishes_info = [dish.get_info() for dish in self.dishes]\n",
    "        return f\"Menu: {self.name} Dishes: {''.join([f'- {info}' for info in dishes_info])}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "55441509",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Menu: Italian Cuisine Dishes: - Dish: Margherita Pizza Ingredients: Ingredient: Tomato, Ingredient: Cheese, Ingredient: Dough, Ingredient: Basil- Dish: Caprese Salad Ingredients: Ingredient: Tomato, Ingredient: Cheese, Ingredient: Basil\n"
     ]
    }
   ],
   "source": [
    "# Creating ingredients\n",
    "ingredient1 = Ingredient(\"Tomato\")\n",
    "ingredient2 = Ingredient(\"Cheese\")\n",
    "ingredient3 = Ingredient(\"Dough\")\n",
    "ingredient4 = Ingredient(\"Basil\")\n",
    "\n",
    "# Creating dishes\n",
    "pizza_ingredients = [ingredient1, ingredient2, ingredient3, ingredient4]\n",
    "pizza = Dish(\"Margherita Pizza\", pizza_ingredients)\n",
    "\n",
    "salad_ingredients = [ingredient1, ingredient2, ingredient4]\n",
    "salad = Dish(\"Caprese Salad\", salad_ingredients)\n",
    "\n",
    "# Creating a menu\n",
    "menu_dishes = [pizza, salad]\n",
    "restaurant_menu = Menu(\"Italian Cuisine\", menu_dishes)\n",
    "\n",
    "# Getting information about the menu\n",
    "print(restaurant_menu.get_info())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72651f59",
   "metadata": {},
   "source": [
    "#### 15. Explain how composition enhances code maintainability and modularity in Python programs.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "43ab84d5",
   "metadata": {},
   "source": [
    "1. Modularity:\n",
    "*) Component Reusability: Composition allows for the creation of smaller, reusable components that can be utilized in various contexts. These components, when designed well, can be easily integrated into different parts of the codebase.\n",
    "\n",
    "*) Encapsulation of Functionality: Objects created through composition encapsulate specific functionality, allowing for a clear separation of concerns. Each component focuses on a specific task or responsibility, promoting a modular design.\n",
    "\n",
    "2. Maintainability:\n",
    "*) Isolation of Changes: When changes are required, the impact is localized. Modifying or replacing a component through composition typically affects only the immediate containing object. This isolation minimizes the risk of unintended consequences throughout the codebase.\n",
    "\n",
    "*) Readability and Understandability: A well-composed codebase tends to be more readable and understandable. Smaller, focused components are easier to comprehend, aiding developers in maintaining and extending the code.\n",
    "\n",
    "3. Flexibility and Scalability:\n",
    "*) Dynamic Configuration: Composition allows for dynamic configurations by assembling objects at runtime. This flexibility enables easy modifications or substitutions of components, making the system adaptable to changing requirements.\n",
    "\n",
    "*) Scalability: As the system grows, composing smaller components into larger, more complex structures enables scalability. New functionalities can be added by integrating new components without significantly altering existing code.\n",
    "\n",
    "4. Encapsulation and Dependency Management:\n",
    "*) Encapsulation: Composition promotes encapsulation by allowing objects to manage their internal state and behaviors. Objects hide their implementation details, exposing only the necessary interfaces, which simplifies interaction between components.\n",
    "\n",
    "*) Dependency Management: Through composition, dependencies between components can be managed effectively. Objects can be designed to depend on abstractions rather than concrete implementations, reducing coupling and making it easier to swap components.\n",
    "\n",
    "5. Testing and Debugging:\n",
    "*) Unit Testing: Smaller, modular components created through composition are easier to test individually, promoting effective unit testing. This granularity allows for more focused and targeted testing, enhancing code reliability.\n",
    "\n",
    "*) Debugging: In case of issues, having well-defined components simplifies the debugging process. Isolating problems to specific components makes it easier to identify and resolve issues."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08f6561d",
   "metadata": {},
   "source": [
    "#### 16. Create a Python class for a computer game character, using composition to represent attributes like weapons, armor, and inventory.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "ddee4b6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Weapon:\n",
    "    def __init__(self, name, damage):\n",
    "        self.name = name\n",
    "        self.damage = damage\n",
    "\n",
    "    def get_info(self):\n",
    "        return 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 get_info(self):\n",
    "        return f\"Armor: {self.name}, Defense: {self.defense}\"\n",
    "\n",
    "class Inventory:\n",
    "    def __init__(self):\n",
    "        self.items = []\n",
    "\n",
    "    def add_item(self, item):\n",
    "        self.items.append(item)\n",
    "\n",
    "    def get_inventory_info(self):\n",
    "        return [item.get_info() for item in self.items]\n",
    "\n",
    "class Character:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.weapon = None  # Composition: Character has a Weapon\n",
    "        self.armor = None  # Composition: Character has Armor\n",
    "        self.inventory = Inventory()  # Composition: Character has an Inventory\n",
    "\n",
    "    def equip_weapon(self, weapon):\n",
    "        self.weapon = weapon\n",
    "\n",
    "    def equip_armor(self, armor):\n",
    "        self.armor = armor\n",
    "\n",
    "    def add_item_to_inventory(self, item):\n",
    "        self.inventory.add_item(item)\n",
    "\n",
    "    def get_character_info(self):\n",
    "        weapon_info = self.weapon.get_info() if self.weapon else \"No weapon equipped.\"\n",
    "        armor_info = self.armor.get_info() if self.armor else \"No armor equipped.\"\n",
    "        inventory_info = self.inventory.get_inventory_info() if self.inventory.items else \"Inventory is empty.\"\n",
    "\n",
    "        return f\"Character: {self.name}\\n{weapon_info}\\n{armor_info}\\nInventory:\\n{', '.join(inventory_info)}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "8f4f24e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Character: Hero\n",
      "Weapon: Sword, Damage: 20\n",
      "Armor: Shield, Defense: 10\n",
      "Inventory:\n",
      "Weapon: Bow, Damage: 15, Armor: Helmet, Defense: 5\n"
     ]
    }
   ],
   "source": [
    "# Creating weapons\n",
    "sword = Weapon(\"Sword\", 20)\n",
    "bow = Weapon(\"Bow\", 15)\n",
    "\n",
    "# Creating armor\n",
    "shield = Armor(\"Shield\", 10)\n",
    "helmet = Armor(\"Helmet\", 5)\n",
    "\n",
    "# Creating a character\n",
    "hero = Character(\"Hero\")\n",
    "\n",
    "# Equipping the character with weapons and armor\n",
    "hero.equip_weapon(sword)\n",
    "hero.equip_armor(shield)\n",
    "\n",
    "# Adding items to the character's inventory\n",
    "hero.add_item_to_inventory(bow)\n",
    "hero.add_item_to_inventory(helmet)\n",
    "\n",
    "# Getting character information\n",
    "print(hero.get_character_info())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afe1d58c",
   "metadata": {},
   "source": [
    "#### 17. Describe the concept of \"aggregation\" in composition and how it differs from simple composition.\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "84f36de8",
   "metadata": {},
   "source": [
    "In object-oriented programming, \"aggregation\" is a form of composition where one object, referred to as the containing or whole object, contains references to other objects, known as parts or components. The main distinction between simple composition and aggregation lies in the relationship and lifecycle management between the containing object and its components.\n",
    "\n",
    "\n",
    "Characteristics of Aggregation:\n",
    " \n",
    " \n",
    "1) \"Has-A\" Relationship:\n",
    "Aggregation represents a \"has-a\" relationship, indicating that the containing object \"has\" or \"contains\" instances of other objects. For example, a car \"has\" wheels.\n",
    "\n",
    "2) Independent Lifecycle:\n",
    "In aggregation, the lifecycle of the contained objects is not directly tied to the containing object. The components can exist independently and can be shared among multiple containing objects.\n",
    "\n",
    "3) Weak Relationship:\n",
    "Aggregation implies a weaker relationship between the containing object and its components. The components can be added, removed, or replaced without fundamentally altering the containing object.\n",
    "\n",
    "4) Component Reusability:\n",
    "Aggregation allows for reusing components in different contexts. Components can exist outside the scope of the containing object and be used elsewhere.\n",
    "Cardinality:\n",
    "\n",
    "Aggregation may have a cardinality relationship, indicating how many instances of a component can be associated with the containing object (e.g., one-to-one, one-to-many).\n",
    "\n",
    "Differences from Simple Composition:\n",
    "\n",
    "1) Lifecycle Dependency:\n",
    "In simple composition, the lifecycle of the components is tightly coupled with the containing object. If the containing object is destroyed, the components are usually destroyed as well. In aggregation, the destruction of the containing object doesn't necessarily lead to the destruction of its components.\n",
    "\n",
    "2) Ownership and Management:\n",
    "Simple composition often implies ownership, where the containing object manages the creation, modification, and destruction of its components. In contrast, aggregation allows components to exist independently, and their management might not solely rely on the containing object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62507001",
   "metadata": {},
   "source": [
    "#### 18. Create a Python class for a house, using composition to represent rooms, furniture, and appliances.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "3d17929f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Furniture:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"Furniture: {self.name}\"\n",
    "\n",
    "class Appliance:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"Appliance: {self.name}\"\n",
    "\n",
    "class Room:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.furniture = []  # Composition: Room has Furniture\n",
    "        self.appliances = []  # Composition: Room has Appliances\n",
    "\n",
    "    def add_furniture(self, furniture):\n",
    "        self.furniture.append(furniture)\n",
    "\n",
    "    def add_appliance(self, appliance):\n",
    "        self.appliances.append(appliance)\n",
    "\n",
    "    def get_room_info(self):\n",
    "        furniture_info = [item.get_info() for item in self.furniture]\n",
    "        appliance_info = [item.get_info() for item in self.appliances]\n",
    "        return f\"Room: {self.name}\\nFurniture: {', '.join(furniture_info)}\\nAppliances: {', '.join(appliance_info)}\"\n",
    "\n",
    "class House:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.rooms = []  # Composition: House has Rooms\n",
    "\n",
    "    def add_room(self, room):\n",
    "        self.rooms.append(room)\n",
    "\n",
    "    def get_house_info(self):\n",
    "        room_info = [room.get_room_info() for room in self.rooms]\n",
    "        return f\"House: {self.name}\\n{''.join(room_info)}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "46654147",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "House: My House\n",
      "Room: Living Room\n",
      "Furniture: Furniture: Sofa, Furniture: Coffee Table\n",
      "Appliances: Appliance: TelevisionRoom: Kitchen\n",
      "Furniture: \n",
      "Appliances: Appliance: Refrigerator\n"
     ]
    }
   ],
   "source": [
    "# Creating furniture and appliances\n",
    "sofa = Furniture(\"Sofa\")\n",
    "table = Furniture(\"Coffee Table\")\n",
    "tv = Appliance(\"Television\")\n",
    "fridge = Appliance(\"Refrigerator\")\n",
    "\n",
    "# Creating rooms\n",
    "living_room = Room(\"Living Room\")\n",
    "living_room.add_furniture(sofa)\n",
    "living_room.add_furniture(table)\n",
    "living_room.add_appliance(tv)\n",
    "\n",
    "kitchen = Room(\"Kitchen\")\n",
    "kitchen.add_appliance(fridge)\n",
    "\n",
    "# Creating a house and adding rooms\n",
    "my_house = House(\"My House\")\n",
    "my_house.add_room(living_room)\n",
    "my_house.add_room(kitchen)\n",
    "\n",
    "# Getting house information\n",
    "print(my_house.get_house_info())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "713e8565",
   "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": "raw",
   "id": "d612ce2d",
   "metadata": {},
   "source": [
    "chieving flexibility in composed objects to allow dynamic replacement or modification at runtime involves implementing patterns or strategies that enable altering the components without impacting the entire system. Here are a few approaches to accomplish this:\n",
    "\n",
    "1. Dependency Injection:\n",
    "-> Strategy: Instead of hardcoding dependencies within a class, inject them externally during object creation or through setter methods. This allows swapping components dynamically without altering the class's implementation.\n",
    "-> Example: Pass components (objects) as arguments during object initialization or provide setter methods to update components.\n",
    "\n",
    "2. Factory Patterns:\n",
    "-> Strategy: Use factory methods or factory classes to create objects dynamically based on requirements. Factories can encapsulate the logic of object creation and allow switching between different implementations.\n",
    "-> Example: Create factories that produce different variations of components based on conditions or configurations.\n",
    "\n",
    "3. Decorator Pattern:\n",
    "-> Strategy: Wrap objects with decorators that add or modify behavior dynamically. Decorators maintain the original object's interface but can alter its functionality.\n",
    "-> Example: Create decorators that add additional functionalities to existing objects without changing their core structure.\n",
    "\n",
    "4. Polymorphism and Interfaces:\n",
    "-> Strategy: Utilize polymorphism and interfaces to define contracts or common interfaces for components. This allows interchangeable usage of different implementations that adhere to the same interface.\n",
    "-> Example: Design components to conform to specific interfaces, allowing them to be replaced with other objects that implement the same interface."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d251ed7",
   "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": 34,
   "id": "c1760d77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Post by Mit: Hello, this is my first post!\n",
      " - Comment by Mit: Nice post!\n",
      "Post by tmr: Python is awesome!\n",
      " - Comment by tmr: Totally agree!\n"
     ]
    }
   ],
   "source": [
    "class User:\n",
    "    def __init__(self, username, email):\n",
    "        self.username = username\n",
    "        self.email = email\n",
    "        self.posts = []\n",
    "        self.comments = []\n",
    "\n",
    "    def create_post(self, content):\n",
    "        post = Post(content, self.username)\n",
    "        self.posts.append(post)\n",
    "        return post\n",
    "\n",
    "    def add_comment(self, post, content):\n",
    "        comment = Comment(content, self.username)\n",
    "        post.add_comment(comment)\n",
    "        self.comments.append(comment)\n",
    "\n",
    "    def display_posts(self):\n",
    "        for post in self.posts:\n",
    "            print(f\"Post by {post.author}: {post.content}\")\n",
    "            post.display_comments()\n",
    "\n",
    "\n",
    "class Post:\n",
    "    def __init__(self, content, author):\n",
    "        self.content = content\n",
    "        self.author = author\n",
    "        self.comments = []\n",
    "\n",
    "    def add_comment(self, comment):\n",
    "        self.comments.append(comment)\n",
    "\n",
    "    def display_comments(self):\n",
    "        for comment in self.comments:\n",
    "            print(f\" - Comment by {comment.author}: {comment.content}\")\n",
    "\n",
    "\n",
    "class Comment:\n",
    "    def __init__(self, content, author):\n",
    "        self.content = content\n",
    "        self.author = author\n",
    "\n",
    "\n",
    "# Example usage of the social media application\n",
    "user1 = User(\"Mit\", \"Mit@example.com\")\n",
    "user2 = User(\"tmr\", \"tmr@example.com\")\n",
    "\n",
    "post1 = user1.create_post(\"Hello, this is my first post!\")\n",
    "user1.add_comment(post1, \"Nice post!\")\n",
    "\n",
    "post2 = user2.create_post(\"Python is awesome!\")\n",
    "user2.add_comment(post2, \"Totally agree!\")\n",
    "\n",
    "user1.display_posts()\n",
    "user2.display_posts()\n"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}