02_July_OOPs_inheritance.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNpN/pu5t5YvCy3p7zEDHHT",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/PritamBadwar/assignments_fsds/blob/main/02_July_OOPs_inheritance.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Explain what inheritance is in object-oriented programming and why it is used.\n",
        "Ans:\n",
        "  - Fundamental concept that allows a class to inherit attributes (data members) and behaviours (methods/functions) from another class\n",
        "  - one class is considered as a specialized version of other class\n",
        "  - Parent class or child or derives classes\n",
        "  - Primary reason of use is as below:\n",
        "    - Code reusability\n",
        "    - Polymorphism\n",
        "    - Encapsulation\n",
        "    - Modularity\n",
        "  - This facilitates code reusability, organization, extensibility. how it should be used judiciously considering the principles of good software design to avoid deep inheritance hierarchies"
      ],
      "metadata": {
        "id": "paGGTPfLjrBL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. Discuss the concept of single inheritance and multiple inheritance, highlighting their differences and advantages.\n",
        "Ans:\n",
        "  - Single inheritance: where class inherits from only one parent class\n",
        "    - Single inheritane provides simplicity and less ambiguity\n",
        "  - Multiple inheritance: where class inherits from more than one parent class\n",
        "    - This inheritance provies code reusability, Rich class composition, Encourages mixins"
      ],
      "metadata": {
        "id": "cKtfIpf_jrVr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. Explain the terms \"base class\" and \"derived class\" in the context of inheritance.\n",
        "Ans:\n",
        "  - Base Class:\n",
        "    - Parent or super class\n",
        "    - It is class from which attributes and methods are inherited\n",
        "    - The base class provides a set of functionalities that derived classes can extend or over write\n",
        "  - Derived class:\n",
        "    - Child class\n",
        "    - Is the class that inherits attributes and methods from base class\n",
        "    - By extending the functionality or overriding the existing method to provide the specialized implementation"
      ],
      "metadata": {
        "id": "N0sAEX7AjrYs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "4. What is the significance of the \"protected\" access modifier in inheritance? How does it differ from \"private\" and \"public\" modifiers?\n",
        "Ans:\n",
        "  - Inn oop, access modifiers or visibility modifiers control the visibility of class members (attributes and methods) from outside the class\n",
        "  - These modifiers helps enforce encapsulation, imp in oop\n",
        "  1. Protected access modifiers:\n",
        "    - Start with prefix as _protected_variable\n",
        "    - can be acccessed within classes and subclass\n",
        "    - can be also accessed outside class, but its usage discouraged\n",
        "  2. Private access modifiers:\n",
        "    - start with prefix of __protected_variable\n",
        "    - can not be accessed within derived class\n",
        "  3. Publish acccess modifiers:\n",
        "    - do not start with any prefix\n",
        "    - can be accessed within derived class and also outside class"
      ],
      "metadata": {
        "id": "0EU-_jkKjrbl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "5. What is the purpose of the \"super\" keyword in inheritance? Provide an example.\n",
        "Ans:\n",
        "  - Super keyword used to call method from parent class, enabling to extend the functionality while preserving original behaviour of method\n",
        "  - e.g below"
      ],
      "metadata": {
        "id": "i1-blo1Fjrec"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Animal:\n",
        "  def make_sound(self):\n",
        "    return \"generic animal sound\"\n",
        "class Dog(Animal):\n",
        "  def make_sound(self):\n",
        "   #calling the overridden method from parent class\n",
        "    base_sound = super().make_sound()\n",
        "    return f\"{base_sound} - wolf\"\n",
        "\n",
        "#create an instance of derived class\n",
        "dog = Dog()\n",
        "\n",
        "#call the method in the derived class\n",
        "print(dog.make_sound())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TcpCnesIp4jm",
        "outputId": "2d176cf6-6418-49f3-c5c6-191f71908cd7"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "generic animal sound - wolf\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "6. Create a base class called \"Vehicle\" with attributes like \"make\", \"model\", and \"year\".\n",
        "Then, create a derived class called \"Car\" that inherits from \"Vehicle\" and adds an\n",
        "attribute called \"fuel_type\". Implement appropriate methods in both classes."
      ],
      "metadata": {
        "id": "dr2UEJDejrhE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Vehicle:\n",
        "    def __init__(self, make, model, year):\n",
        "        self.make = make\n",
        "        self.model = model\n",
        "        self.year = year\n",
        "\n",
        "    def get_details(self):\n",
        "        return f\"{self.year} {self.make} {self.model}\"\n",
        "\n",
        "\n",
        "class Car(Vehicle):\n",
        "    def __init__(self, make, model, year, fuel_type):\n",
        "        # Call the constructor of the base class\n",
        "        super().__init__(make, model, year)\n",
        "        self.fuel_type = fuel_type\n",
        "\n",
        "    def get_details(self):\n",
        "        # Call the method from the base class and add fuel type\n",
        "        vehicle_details = super().get_details()\n",
        "        return f\"{vehicle_details}, Fuel Type: {self.fuel_type}\"\n",
        "\n",
        "\n",
        "# Create an instance of the Car class\n",
        "my_car = Car(\"Toyota\", \"Corolla\", 2022, \"Petrol\")\n",
        "\n",
        "# Call the method from the Car class\n",
        "print(my_car.get_details())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mHG6nrEO74Mp",
        "outputId": "006a40b6-d51c-46b4-951c-0eaf48a24cdd"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2022 Toyota Corolla, Fuel Type: Petrol\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "7. Create a base class called \"Employee\" with attributes like \"name\" and \"salary.\"\n",
        "Derive two classes, \"Manager\" and \"Developer,\" from \"Employee.\" Add an additional\n",
        "attribute called \"department\" for the \"Manager\" class and \"programming_language\"\n",
        "for the \"Developer\" class."
      ],
      "metadata": {
        "id": "-RIPtQW3jrjq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Employee:\n",
        "    def __init__(self, name, salary):\n",
        "        self.name = name\n",
        "        self.salary = salary\n",
        "\n",
        "    def display_details(self):\n",
        "        return f\"Name: {self.name}, Salary: {self.salary}\"\n",
        "\n",
        "\n",
        "class Manager(Employee):\n",
        "    def __init__(self, name, salary, department):\n",
        "        # Call the constructor of the base class\n",
        "        super().__init__(name, salary)\n",
        "        self.department = department\n",
        "\n",
        "    def display_details(self):\n",
        "        # Call the method from the base class and add department info\n",
        "        employee_details = super().display_details()\n",
        "        return f\"{employee_details}, Department: {self.department}\"\n",
        "\n",
        "\n",
        "class Developer(Employee):\n",
        "    def __init__(self, name, salary, programming_language):\n",
        "        # Call the constructor of the base class\n",
        "        super().__init__(name, salary)\n",
        "        self.programming_language = programming_language\n",
        "\n",
        "    def display_details(self):\n",
        "        # Call the method from the base class and add programming language info\n",
        "        employee_details = super().display_details()\n",
        "        return f\"{employee_details}, Programming Language: {self.programming_language}\"\n",
        "\n",
        "\n",
        "# Create instances of the Manager and Developer classes\n",
        "manager = Manager(\"John Doe\", 60000, \"Human Resources\")\n",
        "developer = Developer(\"Jane Smith\", 70000, \"Python\")\n",
        "\n",
        "# Display details of the manager and developer\n",
        "print(manager.display_details())\n",
        "print(developer.display_details())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CVhMvdcS8iF7",
        "outputId": "7f34931e-375d-4aec-f4d1-e67f61d2986d"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name: John Doe, Salary: 60000, Department: Human Resources\n",
            "Name: Jane Smith, Salary: 70000, Programming Language: Python\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "8. Design a base class called \"Shape\" with attributes like \"colour\" and \"border_width.\"\n",
        "Create derived classes, \"Rectangle\" and \"Circle,\" that inherit from \"Shape\" and add\n",
        "specific attributes like \"length\" and \"width\" for the \"Rectangle\" class and \"radius\" for\n",
        "the \"Circle\" class."
      ],
      "metadata": {
        "id": "wTlxyOhyjrmQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Shape:\n",
        "    def __init__(self, colour, border_width):\n",
        "        self.colour = colour\n",
        "        self.border_width = border_width\n",
        "\n",
        "    def display_details(self):\n",
        "        return f\"Colour: {self.colour}, Border Width: {self.border_width}\"\n",
        "\n",
        "\n",
        "class Rectangle(Shape):\n",
        "    def __init__(self, colour, border_width, length, width):\n",
        "        # Call the constructor of the base class\n",
        "        super().__init__(colour, border_width)\n",
        "        self.length = length\n",
        "        self.width = width\n",
        "\n",
        "    def display_details(self):\n",
        "        # Call the method from the base class and add rectangle-specific info\n",
        "        shape_details = super().display_details()\n",
        "        return f\"{shape_details}, Length: {self.length}, Width: {self.width}\"\n",
        "\n",
        "\n",
        "class Circle(Shape):\n",
        "    def __init__(self, colour, border_width, radius):\n",
        "        # Call the constructor of the base class\n",
        "        super().__init__(colour, border_width)\n",
        "        self.radius = radius\n",
        "\n",
        "    def display_details(self):\n",
        "        # Call the method from the base class and add circle-specific info\n",
        "        shape_details = super().display_details()\n",
        "        return f\"{shape_details}, Radius: {self.radius}\"\n",
        "\n",
        "\n",
        "# Create instances of the Rectangle and Circle classes\n",
        "rectangle = Rectangle(\"Blue\", 2, 10, 5)\n",
        "circle = Circle(\"Red\", 1, 7)\n",
        "\n",
        "# Display details of the rectangle and circle\n",
        "print(rectangle.display_details())\n",
        "print(circle.display_details())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o0kqYDBR9N75",
        "outputId": "896a67cc-0000-42a5-b9fe-5d5b0caf5e8e"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Colour: Blue, Border Width: 2, Length: 10, Width: 5\n",
            "Colour: Red, Border Width: 1, Radius: 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "9. Create a base class called \"Device\" with attributes like \"brand\" and \"model.\" Derive\n",
        "two classes, \"Phone\" and \"Tablet,\" from \"Device.\" Add specific attributes like\n",
        "\"screen_size\" for the \"Phone\" class and \"battery_capacity\" for the \"Tablet\" class."
      ],
      "metadata": {
        "id": "89iUN6F5jro2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Device():\n",
        "  def __init__(self, brand, model):\n",
        "    self.brand = brand\n",
        "    self.model = model\n",
        "\n",
        "  def display_details(self):\n",
        "    return f\"Brand: {self.brand}, Model: {self.model}\"\n",
        "\n",
        "class Phone(Device):\n",
        "  def __init__(self,brand,model,screen_size):\n",
        "    #calling the constructor of base class\n",
        "    super().__init__(brand,model)\n",
        "    self.screen_size = screen_size\n",
        "\n",
        "  def display_details(self):\n",
        "    #call the method from base class and add rectangle specific info\n",
        "    device_details = super().display_details()\n",
        "    return f\"{device_details}, screen_size: {self.screen_size}\"\n",
        "\n",
        "class Tablet(Device):\n",
        "  def __init__(self,brand,model,battery_capacity):\n",
        "    #calling the constructor of base class\n",
        "    super().__init__(brand,model)\n",
        "    self.battery_capacity = battery_capacity\n",
        "\n",
        "  def display_details(self):\n",
        "    #call the method from base class and add rectangle specific info\n",
        "    device_details = super().display_details()\n",
        "    return f\"{device_details}, battery_capacity: {self.battery_capacity}\"\n",
        "\n",
        "#create instances of phone and tablet class\n",
        "phone = Phone(\"iPhone\", \"10\", 6)\n",
        "tablet = Tablet(\"itab\", \"12\", 9)\n",
        "\n",
        "#display the details of phone and tablet\n",
        "print(phone.display_details())\n",
        "print(tablet.display_details())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fDlaJows9pBT",
        "outputId": "8a41c9be-f828-4cb9-df8d-079b85db2bb5"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Brand: iPhone, Model: 10, screen_size: 6\n",
            "Brand: itab, Model: 12, battery_capacity: 9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "10. Create a base class called \"BankAccount\" with attributes like \"account_number\" and\n",
        "\"balance.\" Derive two classes, \"SavingsAccount\" and \"CheckingAccount,\" from\n",
        "\"BankAccount.\" Add specific methods like \"calculate_interest\" for the\n",
        "\"SavingsAccount\" class and \"deduct_fees\" for the \"CheckingAccount\" class."
      ],
      "metadata": {
        "id": "hYc1vchWjrrM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class BankAccount:\n",
        "    def __init__(self, account_number, balance):\n",
        "        self.account_number = account_number\n",
        "        self.balance = balance\n",
        "\n",
        "    def deposit(self, amount):\n",
        "        self.balance += amount\n",
        "\n",
        "    def withdraw(self, amount):\n",
        "        if self.balance >= amount:\n",
        "            self.balance -= amount\n",
        "        else:\n",
        "            print(\"Insufficient balance!\")\n",
        "\n",
        "    def display_details(self):\n",
        "        return f\"Account Number: {self.account_number}, Balance: {self.balance:.2f}\"\n",
        "\n",
        "\n",
        "class SavingsAccount(BankAccount):\n",
        "    def __init__(self, account_number, balance, interest_rate):\n",
        "        # Call the constructor of the base class\n",
        "        super().__init__(account_number, balance)\n",
        "        self.interest_rate = interest_rate\n",
        "\n",
        "    def calculate_interest(self):\n",
        "        interest = self.balance * (self.interest_rate / 100)\n",
        "        self.deposit(interest)\n",
        "        print(f\"Interest calculated and added to the account: {interest:.2f}\")\n",
        "\n",
        "\n",
        "class CheckingAccount(BankAccount):\n",
        "    def __init__(self, account_number, balance, transaction_fee):\n",
        "        # Call the constructor of the base class\n",
        "        super().__init__(account_number, balance)\n",
        "        self.transaction_fee = transaction_fee\n",
        "\n",
        "    def deduct_fees(self):\n",
        "        if self.balance >= self.transaction_fee:\n",
        "            self.balance -= self.transaction_fee\n",
        "            print(f\"Transaction fee deducted: {self.transaction_fee:.2f}\")\n",
        "        else:\n",
        "            print(\"Insufficient balance to deduct transaction fee!\")\n",
        "\n",
        "\n",
        "# Create instances of the SavingsAccount and CheckingAccount classes\n",
        "savings_account = SavingsAccount(\"SA12345\", 5000, 2.5)\n",
        "checking_account = CheckingAccount(\"CA98765\", 3000, 10)\n",
        "\n",
        "# Display details of the accounts\n",
        "print(savings_account.display_details())\n",
        "print(checking_account.display_details())\n",
        "\n",
        "# Perform operations specific to each account type\n",
        "savings_account.calculate_interest()\n",
        "checking_account.deduct_fees()\n",
        "\n",
        "# Display updated account details\n",
        "print(savings_account.display_details())\n",
        "print(checking_account.display_details())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SmTsIHtTIfb3",
        "outputId": "eaded7e8-1edf-41e9-8682-0529f7cd86e5"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Account Number: SA12345, Balance: 5000.00\n",
            "Account Number: CA98765, Balance: 3000.00\n",
            "Interest calculated and added to the account: 125.00\n",
            "Transaction fee deducted: 10.00\n",
            "Account Number: SA12345, Balance: 5125.00\n",
            "Account Number: CA98765, Balance: 2990.00\n"
          ]
        }
      ]
    }
  ]
}