ObjectOrientedProgramming(in Python).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Aadil-5122/Object-Oriented-Programming-in-Python/blob/main/ObjectOrientedProgramming(Python)/ObjectOrientedProgramming(in%20Python).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - I - Classes and Objects"
      ],
      "metadata": {
        "id": "4912JSpfmiWa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.1"
      ],
      "metadata": {
        "id": "-JVrg-ukxx8n"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "_UejL4pk_-WC"
      },
      "outputs": [],
      "source": [
        "# position, name, age, level, salary\n",
        "se1 = [\"software engineer\", \"Max\", 20, \"Junior\", 5000]\n",
        "se2 = [\"software engineer\", \"Lisa\", 25, \"Senior\", 7000]"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.2"
      ],
      "metadata": {
        "id": "CtLCclJVxywv"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "gRbSgETGAZq9"
      },
      "outputs": [],
      "source": [
        "# class (blueprint of data structure)\n",
        "class SoftwareEngineer:\n",
        "\n",
        "    # Class Attributes\n",
        "    alias = \"Keyboard Magician\"\n",
        "    \n",
        "    # Special function to initialise our object (Constructor)\n",
        "    # Herein, self attribute will always be there \n",
        "    def __init__(self, name, age, level, salary):\n",
        "\n",
        "        # So the below mentioned attributes with a self keyword,\n",
        "        # are known as instance attributes and can be used inside the class.\n",
        "        # the attributes defined outside this function are called Class Attributes.\n",
        "        \n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        self.level = level\n",
        "        self.salary = salary\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.3"
      ],
      "metadata": {
        "id": "xyRJvhm9xz5c"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "pXTerKJTAsTB"
      },
      "outputs": [],
      "source": [
        "# Difference between Instance and Class Attributes:\n",
        "\n",
        "# Instance Attributes belong to a specific object and not to the whole Class\n",
        "# i.e., we can write: se1.alias, SoftwareEnginner.alias \n",
        "# but not : SoftwareEngineer.name"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.4"
      ],
      "metadata": {
        "id": "DJS8Abn8x0_h"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "tRjW3N2KAxWl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aa13b623-6789-4341-d433-ff1e13302d6c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max 20\n"
          ]
        }
      ],
      "source": [
        "# instance of class (object)\n",
        "se1= SoftwareEngineer(\"Max\", 20, \"Junior\", 5000)\n",
        "print(se1.name, se1.age)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - II(a) - Functions and Classes"
      ],
      "metadata": {
        "id": "6EZeXDS3nILX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.1.1"
      ],
      "metadata": {
        "id": "RQN35Jurx4_d"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "PFNZjaLUBfow"
      },
      "outputs": [],
      "source": [
        "# position, name, age, level, salary\n",
        "se1 = [\"software engineer\", \"Max\", 20, \"Junior\", 5000]\n",
        "se2 = [\"software engineer\", \"Lisa\", 25, \"Senior\", 7000]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.1.2"
      ],
      "metadata": {
        "id": "Xtrb3ghyx6pE"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "-Htyk2FsBgk8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f00b4160-4539-49eb-9a8d-a2d0cbd99e6f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max is writing code\n"
          ]
        }
      ],
      "source": [
        "# Function declaration outside the class\n",
        "\n",
        "def code(se):\n",
        "    print(f\"{se[1]} is writing code\")\n",
        "\n",
        "code(se1)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.1.3"
      ],
      "metadata": {
        "id": "lKReFXNxx7x2"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "7NZCsLOuBihC"
      },
      "outputs": [],
      "source": [
        "# class (blueprint of data structure)\n",
        "\n",
        "class SoftwareEngineer:\n",
        "\n",
        "    alias = \"Keyboard Magician\"\n",
        "    \n",
        "    def __init__(self, name, age, level, salary):\n",
        "        \n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        self.level = level\n",
        "        self.salary = salary\n",
        "\n",
        "    # So, the below declared is an instance method:\n",
        "\n",
        "    # Here, in instance method as well, we need to make sure that the 1st parameter is \"self\"\n",
        "    # This \"self\" keyword would allow the instance method to access all those instance attributes, \n",
        "    # which are declared in constructor    \n",
        "\n",
        "    def code(self):\n",
        "        print(f\"{self.name} is writing code\")\n",
        "\n",
        "    # Parameterised Instance Method:\n",
        "\n",
        "    def code_in_language(self, language):\n",
        "        print(f\"{self.name} is writing code in {language}\")\n",
        "\n",
        "    # Returnable Functions\n",
        "\n",
        "    def information(self):\n",
        "        information = f\"name = {self.name}, age = {self.age}, level = {self.level}\"\n",
        "        return information\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.1.4"
      ],
      "metadata": {
        "id": "sfdOASYMx9CD"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "YOILcZ80Bm42",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1a0360f7-73b6-4fd0-bce4-b11f72a9228c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max 20\n"
          ]
        }
      ],
      "source": [
        "# instance of class (object)\n",
        "se1= SoftwareEngineer(\"Max\", 20, \"Junior\", 5000)\n",
        "se2= SoftwareEngineer(\"Lisa\", 25, \"Senior\", 7000)\n",
        "print(se1.name, se1.age)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.1.5"
      ],
      "metadata": {
        "id": "VjvA0d6fx-LF"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "Ozu-MWDRBqlb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bbdd91d6-a83c-4707-c2d9-6984f82c4bfc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max is writing code\n",
            "Lisa is writing code\n"
          ]
        }
      ],
      "source": [
        "# Calling Instance Method using Instance of Class\n",
        "se1.code()\n",
        "se2.code()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.1.6"
      ],
      "metadata": {
        "id": "Q-PGPOpyx_ML"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "8c3ySe-kBrsC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73165bd6-39f7-47cb-917e-4f9ff342edae"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max is writing code in Python\n",
            "Lisa is writing code in C++\n"
          ]
        }
      ],
      "source": [
        "# Calling the Parameterised Instance Method\n",
        "se1.code_in_language(\"Python\")\n",
        "se2.code_in_language(\"C++\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.1.7"
      ],
      "metadata": {
        "id": "F0pkMOPQyA2i"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "TK9EShhWBtzR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3d6c918e-98a5-4933-e67c-0f2cbb85bf66"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name = Max, age = 20, level = Junior\n"
          ]
        }
      ],
      "source": [
        "# Calling the Instance method which returns information too\n",
        "print(se1.information())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.1.8"
      ],
      "metadata": {
        "id": "sSykPg28yB1T"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "joQ5kDqeBvm2"
      },
      "outputs": [],
      "source": [
        "# Note: We do not pass \"self\" as a parameter while calling an instance method or constructor,\n",
        "# it is because it is already included for us as the first parameter.\n",
        "\n",
        "# So basically the self object specifies the instance of a particular object."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - II(b) - Some Special Instance Methods"
      ],
      "metadata": {
        "id": "4rPCCZ3xnT2o"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.2.1"
      ],
      "metadata": {
        "id": "wvAz95vMyFxn"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "iRQzO5WUCGDG"
      },
      "outputs": [],
      "source": [
        "# --------------------\n",
        "# SECTION - II(b) - Some Special Instance Methods\n",
        "# --------------------\n",
        "\n",
        "# position, name, age, level, salary\n",
        "se1 = [\"software engineer\", \"Max\", 20, \"Junior\", 5000]\n",
        "se2 = [\"software engineer\", \"Lisa\", 25, \"Senior\", 7000]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.2.2"
      ],
      "metadata": {
        "id": "NTxIsjJByG35"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "EdI8WA0FCWbp",
        "outputId": "0d1a7571-fb7c-42b2-ac29-d86b8e594768",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max is writing code\n"
          ]
        }
      ],
      "source": [
        "# Function declaration outside the class\n",
        "def code(se):\n",
        "    print(f\"{se[1]} is writing code\")\n",
        "\n",
        "code(se1)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.2.3"
      ],
      "metadata": {
        "id": "7z-MpL5xyIHl"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "id": "T6GskpEMCY3d"
      },
      "outputs": [],
      "source": [
        "# class (blueprint of data structure)\n",
        "class SoftwareEngineer:\n",
        "\n",
        "    alias = \"Keyboard Magician\"\n",
        "    \n",
        "    def __init__(self, name, age, level, salary):\n",
        "        \n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        self.level = level\n",
        "        self.salary = salary \n",
        "\n",
        "    def code(self):\n",
        "        print(f\"{self.name} is writing code\")\n",
        "\n",
        "    # Parameterized Instance Method:\n",
        "\n",
        "    def code_in_language(self, language):\n",
        "        print(f\"{self.name} is writing code in {language}\")\n",
        "\n",
        "    # Returnable Functions\n",
        "\n",
        "    def information(self):\n",
        "        information = f\"name = {self.name}, age = {self.age}, level = {self.level}\"\n",
        "        return information\n",
        "    \n",
        "    # SOME SPECIAL METHODS:\n",
        "\n",
        "    # These are called \"Double Underscore\" OR \"d underscore\" Methods\n",
        "    # They start with a leading \"double underscore\" and end with a \"trailing double underscore\", Ex. \"init\" function used before\n",
        "    # They are already provided for us in Python\n",
        "    # Every object already has them, So,\n",
        "    # even if we do not declare them in our program, we can use them for any object in the program, because,\n",
        "    # every object already contains implementation of such functions\n",
        "\n",
        "    # if we have defined our own \"d underscore function\", then that will be implemented instead of what already object has\n",
        "\n",
        "    # The below function will get executed whenever our object will get converted to string\n",
        "    # i.e., if we try to print an object, instead of it displaying the class of that object and \n",
        "    # the object's memory location, it will implement \"__str__\" function\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        information = f\"name = {self.name}, age = {self.age}, level = {self.level}\"\n",
        "        return information\n",
        "    \n",
        "    # we can clearly see that the above function can be used instead of,\n",
        "    # our previously defined function named \"information\"\n",
        "\n",
        "    # ANOTHER Special Function: \"__eq__\"\n",
        "    # It has two mandatory parameters: \"self\" and \"other\"\n",
        "    # This is used for comparing two objects\n",
        "    # By Default (i.e. if we do not declare it in our program),\n",
        "    # It will compare the memory addresses of both the objects \n",
        "\n",
        "    def __eq__(self, other) -> str:\n",
        "        return self.name == other.name and self.age == other.age\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.2.4"
      ],
      "metadata": {
        "id": "gOXo2eiFyK6g"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "id": "XEsrR1vGCh4I",
        "outputId": "d76e082c-561b-4163-b7ff-0f55d56406e7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max 20\n"
          ]
        }
      ],
      "source": [
        "# instance of class (object)\n",
        "se1= SoftwareEngineer(\"Max\", 20, \"Junior\", 5000)\n",
        "se2= SoftwareEngineer(\"Lisa\", 25, \"Senior\", 7000)\n",
        "se3= SoftwareEngineer(\"Lisa\", 25, \"Senior\", 7000)\n",
        "print(se1.name, se1.age)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.2.5"
      ],
      "metadata": {
        "id": "4xB0q1yRyMEW"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "hbbDcFW_CjhX",
        "outputId": "2712f33d-c38d-4a4c-a21b-4d36e2001d98",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max is writing code\n",
            "Lisa is writing code\n",
            "Max is writing code in Python\n"
          ]
        }
      ],
      "source": [
        "se1.code()\n",
        "se2.code()\n",
        "\n",
        "se1.code_in_language(\"Python\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - II(c) - Functions with implementation using Decorators"
      ],
      "metadata": {
        "id": "plVTcdrvnaaE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.3.1"
      ],
      "metadata": {
        "id": "bGWFvdgbyPh0"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "GyDbIjbvC5EV"
      },
      "outputs": [],
      "source": [
        "# --------------------\n",
        "# SECTION - II(c) - Functions with implementation using Decorators\n",
        "# --------------------\n",
        "\n",
        "# position, name, age, level, salary\n",
        "se1 = [\"software engineer\", \"Max\", 20, \"Junior\", 5000]\n",
        "se2 = [\"software engineer\", \"Lisa\", 25, \"Senior\", 7000]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.3.2"
      ],
      "metadata": {
        "id": "5KySlHTtyQmH"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "S7IQEzd-DVVg",
        "outputId": "a7857e02-fb37-4fe1-aa0a-48c7adf33363",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max is writing code\n"
          ]
        }
      ],
      "source": [
        "# Function declaration outside the class\n",
        "\n",
        "def code(se):\n",
        "    print(f\"{se[1]} is writing code\")\n",
        "\n",
        "code(se1)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.3.3"
      ],
      "metadata": {
        "id": "fPQzSzepyR2X"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "id": "DYwDiZEXDXCV"
      },
      "outputs": [],
      "source": [
        "# class (blueprint of data structure)\n",
        "\n",
        "class SoftwareEngineer:\n",
        "\n",
        "    alias = \"Keyboard Magician\"\n",
        "    \n",
        "    def __init__(self, name, age, level, salary):\n",
        "        \n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        self.level = level\n",
        "        self.salary = salary \n",
        "\n",
        "    def code(self):\n",
        "        print(f\"{self.name} is writing code\")\n",
        "\n",
        "    # Parameterised Instance Method:\n",
        "\n",
        "    def code_in_language(self, language):\n",
        "        print(f\"{self.name} is writing code in {language}\")\n",
        "\n",
        "    # Returnable Functions\n",
        "\n",
        "    def information(self):\n",
        "        information = f\"name = {self.name}, age = {self.age}, level = {self.level}\"\n",
        "        return information\n",
        "\n",
        "    def __str__(self) -> str:\n",
        "        information = f\"name = {self.name}, age = {self.age}, level = {self.level}\"\n",
        "        return information\n",
        "\n",
        "    def __eq__(self, other) -> str:\n",
        "        return self.name == other.name and self.age == other.age\n",
        "    \n",
        "    # Functions without the \"self\" parameter\n",
        "    # May be intentional / unintentional according to the programmer\n",
        "    \n",
        "    # If we try to call this function using an object of class by passing \"age\" (here) as a parameter,\n",
        "    # the error which will pop in that: \"one positional argument was required and two were given\"\n",
        "    # REASON: As told before, for every object, \"self\" is an automatically passed parameter,\n",
        "    # Therefore the statement \"se1.entry_salary(24)\" is considered as \"self.entry_salary(self, 24)\",\n",
        "    # but our function is defined to accept only one argument \n",
        "\n",
        "    # this will work if we call it using the class name: i.e.,\n",
        "    # SoftwareEnginner.entry_salary(24)\n",
        "\n",
        "    @staticmethod\n",
        "    def entry_salary(age):\n",
        "        if age < 25:\n",
        "            return 5000\n",
        "        if age < 30:\n",
        "            return 7000\n",
        "        return 9000\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.3.4"
      ],
      "metadata": {
        "id": "gZrIcmAgyTRP"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "id": "kb2n0niZDZaF",
        "outputId": "e7aa512c-fb2a-460a-f4ef-f2f6c3a78783",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max 20\n",
            "Max is writing code\n",
            "Lisa is writing code\n",
            "Max is writing code in Python\n",
            "Lisa is writing code in C++\n"
          ]
        }
      ],
      "source": [
        "# instance of class (object)\n",
        "se1= SoftwareEngineer(\"Max\", 20, \"Junior\", 5000)\n",
        "se2= SoftwareEngineer(\"Lisa\", 25, \"Senior\", 7000)\n",
        "se3= SoftwareEngineer(\"Lisa\", 25, \"Senior\", 7000)\n",
        "print(se1.name, se1.age)\n",
        "\n",
        "se1.code()\n",
        "se2.code()\n",
        "\n",
        "se1.code_in_language(\"Python\")\n",
        "se2.code_in_language(\"C++\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.3.5"
      ],
      "metadata": {
        "id": "rMzQlUSvyVSF"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "yQN3Uy1sDbkj",
        "outputId": "eee6a24a-eb3e-4229-c61b-8d865570385b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name = Max, age = 20, level = Junior\n",
            "name = Max, age = 20, level = Junior\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "print(se1.information())\n",
        "\n",
        "print(se1)\n",
        "\n",
        "print(se2 == se3)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2.3.6"
      ],
      "metadata": {
        "id": "lhpVawF9yWdj"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "id": "28dskMSKDd7x",
        "outputId": "a1a87193-6fda-49a5-ee29-b942f3ecdc22",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7000\n",
            "<function SoftwareEngineer.entry_salary at 0x7f3edda1d360>\n"
          ]
        }
      ],
      "source": [
        "# entry_salary function called using the \"Class Name\"\n",
        "# instead of object\n",
        "print(SoftwareEngineer.entry_salary(27))\n",
        "\n",
        "# So if we want to access an instance method which has no attribute \"self\",\n",
        "# We use a \"DECORATOR\" named \"@staticmethod\", which allows us to call that function,\n",
        "# with the help of an object of that class too\n",
        "\n",
        "print(se1.entry_salary)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - III(a) - Inheritance"
      ],
      "metadata": {
        "id": "yjRUDPmrnfjx"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "D-GwTkWPEK5_"
      },
      "outputs": [],
      "source": [
        "# Process in which one class takes in attributes and methods of one class,\n",
        "# So, this newly formed class is then called \"Child Class\" and\n",
        "# Other one is called \"Parent Class\"\n",
        "\n",
        "# Using Inheritance, we can: \n",
        "# 1. Inherit a Class\n",
        "# 2. Extend a Class\n",
        "# 3. OverRide a Class\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.1.1"
      ],
      "metadata": {
        "id": "CbTaE81pydYh"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "id": "Xxzi-QAwELmc"
      },
      "outputs": [],
      "source": [
        "class Employee: # Parent Class\n",
        "    def __init__(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "\n",
        "        # Now both the Child Classes have the above instance attributes,\n",
        "        # i.e., the \"age\" and the \"name\"\n",
        "\n",
        "    # Same goes for Instance Methods,\n",
        "    # i.e., Child Class Inherits Instance Methods as well\n",
        "\n",
        "    def work(self):\n",
        "        print(f'{self.name} is working')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.1.2"
      ],
      "metadata": {
        "id": "WSp0MBwByfQO"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "kYGMzxrXESxC"
      },
      "outputs": [],
      "source": [
        "class SoftwareEngineer(Employee): # Syntax for a Child Class\n",
        "    pass\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.1.3"
      ],
      "metadata": {
        "id": "LUtwIatcygP2"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "id": "RGMNiyEDEUkq"
      },
      "outputs": [],
      "source": [
        "class Designer(Employee): # Syntax for a Child Class\n",
        "    pass\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.1.4"
      ],
      "metadata": {
        "id": "zwmESAaRyhfY"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "id": "vljk-7FjEWXR",
        "outputId": "2419465a-9ff4-4e6b-ea78-ab287f4a5169",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max 24\n",
            "Max is working\n",
            "Phillip 27\n",
            "Phillip is working\n"
          ]
        }
      ],
      "source": [
        "# Implementation of Child Class using the instance attributes and methods of Parent Class\n",
        "\n",
        "se = SoftwareEngineer(\"Max\", 24)\n",
        "print(se.name, se.age)\n",
        "se.work()\n",
        "\n",
        "d = Designer(\"Phillip\", 27)\n",
        "print(d.name, d.age)\n",
        "d.work()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - III(b) - OverRide a Class Function using Inheritance"
      ],
      "metadata": {
        "id": "NSmDRriYn0-1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.2.1"
      ],
      "metadata": {
        "id": "0KUQ4La9yj4h"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "id": "HGQjVqRZIZdn"
      },
      "outputs": [],
      "source": [
        "# --------------------\n",
        "# SECTION - III(b) - OverRide a Class Function using Inheritance\n",
        "# --------------------\n",
        "\n",
        "class Employee: # Parent Class\n",
        "    def __init__(self, name, age, salary):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        self.salary = salary\n",
        "\n",
        "    def work(self):\n",
        "        print(f'{self.name} is working')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.2.2"
      ],
      "metadata": {
        "id": "I7_1_WKVylEF"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {
        "id": "qf-PC7osIabl"
      },
      "outputs": [],
      "source": [
        "class SoftwareEngineer(Employee): # Syntax for a Child Class\n",
        "    \n",
        "    def __init__(self, name, age, salary, level):\n",
        "        super().__init__(name, age, salary)\n",
        "\n",
        "        # As this class already has the initialiser function of its Parent Class,\n",
        "        # So to initialise the already existing attributes, we call the Initialser of Parent Class,\n",
        "        # using the above statement \"super().__init__(name, age)\"\n",
        "\n",
        "        self.level = level\n",
        "\n",
        "        # So basically the above attribute \"level\" only works for SoftwareEngineer,\n",
        "        # and not the Designer\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.2.3"
      ],
      "metadata": {
        "id": "A5LFixDFymLZ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "id": "uWitJ0GLIcaE"
      },
      "outputs": [],
      "source": [
        "class Designer(Employee): # Syntax for a Child Class\n",
        "    pass\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.2.4"
      ],
      "metadata": {
        "id": "wjQ-sXdyynSH"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {
        "id": "bJr0Ct8nIePg",
        "outputId": "8ed80fae-4cab-4d8d-f0a9-8ca12b033cfb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max 24\n",
            "Max is working\n",
            "Junior\n"
          ]
        }
      ],
      "source": [
        "# Implementation of Child Class using the instance attributes and methods of Parent Class\n",
        "\n",
        "se = SoftwareEngineer(\"Max\", 24, 6000, \"Junior\")\n",
        "print(se.name, se.age)\n",
        "se.work()\n",
        "print(se.level)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.2.5"
      ],
      "metadata": {
        "id": "edz8Ah4cyog6"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "id": "nDmk1snLIg9N",
        "outputId": "884bb128-1c88-480f-ca49-9d4f949b30b7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Phillip 27\n",
            "Phillip is working\n"
          ]
        }
      ],
      "source": [
        "d = Designer(\"Phillip\", 27, 7000)\n",
        "print(d.name, d.age)\n",
        "d.work()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.2.6"
      ],
      "metadata": {
        "id": "CvCdlbrvyphr"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "id": "Sd5oX8RqIj6C"
      },
      "outputs": [],
      "source": [
        "# Basically what we have done above is,\n",
        "# We have \"over-ridden\" the Parent Class Initialiser Function for a SoftWare Engineer,\n",
        "# Note that it is mandatory to use \"super().__init__()\" for correct initialisation of the object.\n",
        "# Application: We wanted to define \"level\" for a Software Engineer but not the Designer"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yT3UfAeGIeCe"
      },
      "source": [
        "# SECTION - III(c) - Extend a Class Functionality using Inheritance"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.3.1"
      ],
      "metadata": {
        "id": "FXrg6gInysRO"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {
        "id": "-barADtiI5QT"
      },
      "outputs": [],
      "source": [
        "# --------------------\n",
        "# SECTION - III(c) - Extend a Class Functionality using Inheritance\n",
        "# --------------------\n",
        "\n",
        "class Employee: # Parent Class\n",
        "    def __init__(self, name, age, salary):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        self.salary = salary\n",
        "\n",
        "    def work(self):\n",
        "        print(f'{self.name} is working')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.3.2"
      ],
      "metadata": {
        "id": "2-hEbMdjytgI"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "id": "BEkO3CzvI_x3"
      },
      "outputs": [],
      "source": [
        "class SoftwareEngineer(Employee): # Syntax for a Child Class\n",
        "    \n",
        "    def __init__(self, name, age, salary, level):\n",
        "        \n",
        "        super().__init__(name, age, salary)\n",
        "\n",
        "        self.level = level\n",
        "\n",
        "    def debug(self):\n",
        "        print(f\"{self.name} is debugging\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.3.3"
      ],
      "metadata": {
        "id": "3W1ReqBzyv1A"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {
        "id": "5ZNgMWqxJCwr"
      },
      "outputs": [],
      "source": [
        "class Designer(Employee): # Syntax for a Child Class\n",
        "    \n",
        "    def draw(self):\n",
        "        print(f\"{self.name} is drawing\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.3.4"
      ],
      "metadata": {
        "id": "Qle-xTYYyw-C"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {
        "id": "DV7su-_eJEyV",
        "outputId": "d00f0202-626d-4f19-97e8-1bec201bf154",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max 24\n",
            "Max is working\n",
            "Junior\n"
          ]
        }
      ],
      "source": [
        "# Implementation of Child Class using the instance attributes and methods of Parent Class\n",
        "\n",
        "se = SoftwareEngineer(\"Max\", 24, 6000, \"Junior\")\n",
        "print(se.name, se.age)\n",
        "se.work()\n",
        "print(se.level)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.3.5"
      ],
      "metadata": {
        "id": "IDyY_N8Pyx8X"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {
        "id": "44jYpzezJI2D",
        "outputId": "f0b1e8f0-80b6-4714-f535-7c9ea928f35a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Phillip 27\n",
            "Phillip is working\n"
          ]
        }
      ],
      "source": [
        "d = Designer(\"Phillip\", 27, 7000)\n",
        "print(d.name, d.age)\n",
        "d.work()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.3.6"
      ],
      "metadata": {
        "id": "JzEVrfC8yzD3"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "metadata": {
        "id": "Rf6a4Vy9JKdL",
        "outputId": "9ef5ecbf-b0e0-4387-a064-7f4e4dcd7cbe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max is debugging\n",
            "Phillip is drawing\n"
          ]
        }
      ],
      "source": [
        "se.debug()\n",
        "d.draw()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - III(d) - OverRide a Class Function using Inheritance"
      ],
      "metadata": {
        "id": "IR57ScpYn91b"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.4.1"
      ],
      "metadata": {
        "id": "s2CtHc7Sy1Eq"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "metadata": {
        "id": "Vq-l3TudJXe8"
      },
      "outputs": [],
      "source": [
        "# --------------------\n",
        "# SECTION - III(d) - OverRide a Class Function using Inheritance\n",
        "# --------------------\n",
        "\n",
        "# So in simple words, if we CREATE a NEW Function in Child Class:\n",
        "# (a) with same name as in Base Class -> \"Over-Riding\"\n",
        "# (b) with name not in Base Class -> \"Extending\"\n",
        "\n",
        "class Employee: # Parent Class\n",
        "    def __init__(self, name, age, salary):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        self.salary = salary\n",
        "\n",
        "    def work(self):\n",
        "        print(f'{self.name} is working')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.4.2"
      ],
      "metadata": {
        "id": "FlL4X3zey2J-"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 65,
      "metadata": {
        "id": "WBUr5Gm3KGIF"
      },
      "outputs": [],
      "source": [
        "class SoftwareEngineer(Employee): # Syntax for a Child Class\n",
        "    \n",
        "    def __init__(self, name, age, salary, level):\n",
        "        \n",
        "        super().__init__(name, age, salary)\n",
        "\n",
        "        self.level = level\n",
        "\n",
        "    def debug(self):\n",
        "        print(f\"{self.name} is debugging\")\n",
        "\n",
        "    def work(self):\n",
        "        print(f'{self.name} is coding')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.4.3"
      ],
      "metadata": {
        "id": "xxz7u7o-y3s_"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 66,
      "metadata": {
        "id": "GZNK6csuKIga"
      },
      "outputs": [],
      "source": [
        "class Designer(Employee): # Syntax for a Child CLass\n",
        "    \n",
        "    def draw(self):\n",
        "        print(f\"{self.name} is drawing\")\n",
        "\n",
        "    def work(self):\n",
        "        print(f'{self.name} is designing')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.4.4"
      ],
      "metadata": {
        "id": "GuWUkFAvy5y3"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {
        "id": "MSJR-p-jKKPe",
        "outputId": "cd67ce18-fd8f-422a-a688-bc6efd09880b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max 24\n",
            "Junior\n",
            "Phillip 27\n"
          ]
        }
      ],
      "source": [
        "# Implementation of Child Class using the instance attributes and methods of Parent Class\n",
        "\n",
        "se = SoftwareEngineer(\"Max\", 24, 6000, \"Junior\")\n",
        "print(se.name, se.age)\n",
        "print(se.level)\n",
        "\n",
        "d = Designer(\"Phillip\", 27, 7000)\n",
        "print(d.name, d.age)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.4.5"
      ],
      "metadata": {
        "id": "9P1or4FAy6xy"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "id": "_-f8mBPGKL1g",
        "outputId": "949c14ac-bcba-4cd5-eee5-eb44bd7200fd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max is coding\n",
            "Phillip is designing\n"
          ]
        }
      ],
      "source": [
        "se.work()\n",
        "d.work()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - IV - Extension of Inheritance"
      ],
      "metadata": {
        "id": "0ett9GbwoBDq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "4.1"
      ],
      "metadata": {
        "id": "U-udqSP-y-LY"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "id": "t7LHI1iwKiGn"
      },
      "outputs": [],
      "source": [
        "# --------------------\n",
        "# SECTION - IV - Extension of Inheritance\n",
        "# --------------------\n",
        "\n",
        "# POLYMORPHISM:\n",
        "# It alows us to write codes on Base Class, which can work on Child Classes as well.\n",
        "# i.e., we can use a Child Class like its Parent, retaining Child Class's own Attributes.\n",
        "\n",
        "\n",
        "class Employee: # Parent Class\n",
        "    def __init__(self, name, age, salary):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        self.salary = salary\n",
        "\n",
        "    def work(self):\n",
        "        print(f'{self.name} is working')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4.2"
      ],
      "metadata": {
        "id": "4VkXl4NKy_aO"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {
        "id": "uqcxcn_KKsSb"
      },
      "outputs": [],
      "source": [
        "class SoftwareEngineer(Employee): # Syntax for a Child Class\n",
        "    \n",
        "    def __init__(self, name, age, salary, level):\n",
        "        \n",
        "        super().__init__(name, age, salary)\n",
        "\n",
        "        self.level = level\n",
        "\n",
        "    def debug(self):\n",
        "        print(f\"{self.name} is debugging\")\n",
        "\n",
        "    def work(self):\n",
        "        print(f'{self.name} is coding')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4.3"
      ],
      "metadata": {
        "id": "sUrSNDTQzASv"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {
        "id": "WwEAfDUPKuvk"
      },
      "outputs": [],
      "source": [
        "class Designer(Employee): # Syntax for a Child CLass\n",
        "    \n",
        "    def draw(self):\n",
        "        print(f\"{self.name} is drawing\")\n",
        "\n",
        "    def work(self):\n",
        "        print(f'{self.name} is designing')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4.4"
      ],
      "metadata": {
        "id": "UcIvFzQczBNQ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {
        "id": "ao9yg0HeKw1x"
      },
      "outputs": [],
      "source": [
        "employees = [SoftwareEngineer(\"Max\", 25, 6000, \"Junior\"),\n",
        "             SoftwareEngineer(\"Lisa\", 30, 9000, \"Senior\"),\n",
        "             Designer(\"Phillip\", 27, 7000)]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4.5"
      ],
      "metadata": {
        "id": "XmoHjRSFzCOP"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {
        "id": "XGhgTEpGKyYI",
        "outputId": "14b712b5-397e-4e39-89f6-6dc506011dd1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Max is coding\n",
            "Lisa is coding\n",
            "Phillip is designing\n"
          ]
        }
      ],
      "source": [
        "def motivate_employees(employees):\n",
        "    for employee in employees:\n",
        "        employee.work()\n",
        "\n",
        "\n",
        "motivate_employees(employees)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - V(a) - Private Instance Variables"
      ],
      "metadata": {
        "id": "IyWTej47oExb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "5.1.1"
      ],
      "metadata": {
        "id": "zlDDzGqMzEtT"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {
        "id": "k2HBqcGsLQxO"
      },
      "outputs": [],
      "source": [
        "# --------------------\n",
        "# SECTION - V(a) - Private Instance Variables\n",
        "# --------------------\n",
        "\n",
        "# ENCAPSULATION: Hiding of Data Implementation, For exanple, the instance variables \n",
        "# are kept hidden and there is only one Access Method outside, which can Manipulate these Variables.\n",
        "\n",
        "# Instance methods can also be kept private so that they can be used, Only INTERNALLY\n",
        "\n",
        "class SoftwareEngineer:\n",
        "\n",
        "    def __init__(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "\n",
        "        # We declare Private Instance Variables starting with \"_\"\n",
        "        # To initialise them, we use a Function and not the default Constructor\n",
        "        self._salary = None # Private Instance Variable\n",
        "        self.__salary1 = None\n",
        "        self._num_bugs_resolved = 0 # Private Instance Variable\n",
        "\n",
        "    # Also called \"Getter\" Function\n",
        "    def get_salary(self):\n",
        "        return self._salary\n",
        "\n",
        "    # Also called \"Setter\" Function\n",
        "    def set_salary(self, value):\n",
        "        self._salary = value\n",
        "\n",
        "    # Ideally, these two above Functions should be the only Functions who can access,\n",
        "    # Private Instance Variables\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5.1.2"
      ],
      "metadata": {
        "id": "6C85uI0gzGRB"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "id": "bCMMvVunLfa7",
        "outputId": "0377d4bf-6745-4789-80ab-f1d01ee0855a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "25 Max None\n"
          ]
        }
      ],
      "source": [
        "se = SoftwareEngineer(\"Max\", 25)\n",
        "print(se.age, se.name, se._salary)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5.1.3"
      ],
      "metadata": {
        "id": "h-ggmoPozH3p"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "id": "CQVjzo5OLk2z"
      },
      "outputs": [],
      "source": [
        "# As Line 23 easily accessed \"_salary\", therefore in Python the variable with \"_\",\n",
        "# is not actually Private,\n",
        "\n",
        "# To make a variable actually Private, we preceed a variable with \"__\",\n",
        "# i.e. \"double under-score\"\n",
        "\n",
        "# STRICTLY SPEAKING:\n",
        "# \"_x\" is called \"PROTECTED\" attribute\n",
        "# \"__x\" is called \"PRIVATE\" attribute\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5.1.4"
      ],
      "metadata": {
        "id": "y8tjVPKAzJFl"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "id": "7ZptSgoVLm0S",
        "outputId": "0207aa14-3455-4812-8ac7-c3f96f9d707a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6000\n"
          ]
        }
      ],
      "source": [
        "se.set_salary(6000)\n",
        "print(se.get_salary())"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - V(b) - Private Instance Methods"
      ],
      "metadata": {
        "id": "GAkCmr7roH65"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "5.2.1"
      ],
      "metadata": {
        "id": "Kdl9dHF9zLT7"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {
        "id": "CXwAdvMpMES_"
      },
      "outputs": [],
      "source": [
        "# --------------------\n",
        "# SECTION - V(b) - Private Instance Methods\n",
        "# --------------------\n",
        "\n",
        "class SoftwareEngineer:\n",
        "\n",
        "    def __init__(self, name, age):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "\n",
        "        self._salary = None # Private Instance Variable\n",
        "        self.__salary1 = None # Private Instance Variable\n",
        "        self._num_bugs_resolved = 0 # Private Instance Variable\n",
        "\n",
        "    def code(self):\n",
        "        self._num_bugs_resolved += 1\n",
        "\n",
        "    # Also called \"Getter\" Function\n",
        "    def get_salary(self):\n",
        "        return self._salary\n",
        "\n",
        "    # Also called \"Setter\" Function\n",
        "    def set_salary(self, base_value):\n",
        "        self._salary = self._calculate_salary(base_value)\n",
        "\n",
        "    # the names of Private Instance Methods also start with \"_\"\n",
        "\n",
        "    def _calculate_salary(self, base_value):\n",
        "        if self._num_bugs_resolved < 10:\n",
        "            return base_value\n",
        "        if self._num_bugs_resolved < 100:\n",
        "            return base_value * 2\n",
        "        return base_value * 3\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5.2.2"
      ],
      "metadata": {
        "id": "kRncV7XvzM98"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "id": "HPJsU0cMMHJi",
        "outputId": "34833f96-7774-4b29-e5e6-720b2cde48fe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "25 Max None\n"
          ]
        }
      ],
      "source": [
        "se = SoftwareEngineer(\"Max\", 25)\n",
        "print(se.age, se.name, se._salary)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5.2.3"
      ],
      "metadata": {
        "id": "HGncY-P0zONd"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {
        "id": "t9surEzwMJwq",
        "outputId": "e0a262a8-0047-4956-8066-abc1add1160c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12000\n"
          ]
        }
      ],
      "source": [
        "for i in range(70):\n",
        "    se.code()\n",
        "\n",
        "se.set_salary(6000)\n",
        "print(se.get_salary())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# SECTION - VI(a) - Properties"
      ],
      "metadata": {
        "id": "FXGqpjVBoLU_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "6.1"
      ],
      "metadata": {
        "id": "G3b71XybzQvT"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {
        "id": "wt744deHMYNn"
      },
      "outputs": [],
      "source": [
        "# --------------------\n",
        "# SECTION - VI(a) - Properties\n",
        "# --------------------\n",
        "\n",
        "# Now, we will write Getter and Setter Functions in a more \"Pythonic\" way!\n",
        "# i.e., we will use Decorators in Python \n",
        "\n",
        "class SoftwareEngineer:\n",
        "\n",
        "    def __init__(self):\n",
        "        self._salary = None # Private Instance Variable\n",
        "\n",
        "    # def get_salary(self):\n",
        "    #     return self._salary\n",
        "\n",
        "    @property\n",
        "    def salary(self):\n",
        "        return self._salary\n",
        "\n",
        "    # def set_salary(self, value):\n",
        "    #     self._salary = value\n",
        "\n",
        "    @salary.setter\n",
        "    def salary(self, value):\n",
        "        self._salary = value\n",
        "    \n",
        "    # i.e. instead of the conventional way of writing Getter and Setter Functions (as in the commented 4 lines),\n",
        "    # we write them using Decorators, where:\n",
        "    # - Getter and Setter Functions get the same name as the property for which they are getter and setter (here, salary)\n",
        "    # - Decorator of Getter is the built-in Decorator: \"@property\"\n",
        "    # - Decorator of Setter is also built-in but written using the Property name as: \"@salary.setter\"\n",
        "\n",
        "\n",
        "    # General Example of another Decorator pertaining to this topic:\n",
        "\n",
        "    @salary.deleter\n",
        "    def salary(self):\n",
        "        del self._salary"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "6.2"
      ],
      "metadata": {
        "id": "YDteB0hmzSO_"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 82,
      "metadata": {
        "id": "XE77j6cWMnbc",
        "outputId": "d6753933-3c5d-430e-f91e-624b5d10f0e8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6000\n"
          ]
        }
      ],
      "source": [
        "se = SoftwareEngineer()\n",
        "\n",
        "# se.set_salary(6000)\n",
        "# print(se.get_salary())\n",
        "\n",
        "se.salary = 6000\n",
        "print(se.salary)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "6.3"
      ],
      "metadata": {
        "id": "xQHtMuLyzS5P"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {
        "id": "NPnyoYyDMo6M"
      },
      "outputs": [],
      "source": [
        "del se.salary  # to run the third function mentioned above\n",
        "\n",
        "# the above statement will delete the instance variable,\n",
        "# so printing anything pertaining to this variable would throw an error\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "4912JSpfmiWa",
        "6EZeXDS3nILX",
        "4rPCCZ3xnT2o",
        "plVTcdrvnaaE",
        "yjRUDPmrnfjx",
        "NSmDRriYn0-1",
        "yT3UfAeGIeCe",
        "IR57ScpYn91b",
        "0ett9GbwoBDq",
        "IyWTej47oExb",
        "GAkCmr7roH65",
        "FXGqpjVBoLU_"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}