Lecture-12-Object-Oriented-Programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "12f1b3ea",
   "metadata": {},
   "source": [
    "# Object Oriented Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f45012e4",
   "metadata": {},
   "source": [
    "## Class\n",
    "\n",
    "In this section, we will know how to define a class in Python.     \n",
    "We will define a class which has the following methods and attirbutes:\n",
    "- class: `Employee`\n",
    "    - attributes: \n",
    "        1. `name`\n",
    "        2. `salary`\n",
    "    - methods:\n",
    "        1. `set_name`\n",
    "        2. `increase_salary`\n",
    "        3. `set_salary`\n",
    "        \n",
    "In python, classes are defined by `class` keyword and following indented block of code.\n",
    "\n",
    "The attributes in Python classes are defined insided methods using `=` operator.             \n",
    "\n",
    "To refer to an attributes such as `name` inside the class, we use `self.name`. The `self` binds the variable `name` to instance of class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8856baef",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    def set_name(self, new_name):\n",
    "        self.name = new_name\n",
    "        \n",
    "    def set_salary(self, new_salary):\n",
    "        self.salary = new_salary\n",
    "        \n",
    "    def increase_salary(self, amount):\n",
    "        self.salary += amount"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15e82a2a",
   "metadata": {},
   "source": [
    "To create objects (instances) from class, we use the `ClassName()`. In the Employee example, we write this to create an instance of `Employee` class:\n",
    "```Python\n",
    "employee_1 = Employee()\n",
    "```\n",
    "The `employee_1` is an **object** or an **instance** of `Employee` **class**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "196be0d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Javad Ebadi\n",
      "50000\n",
      "100000\n"
     ]
    }
   ],
   "source": [
    "employee_1 = Employee()\n",
    "employee_1.set_name(\"Javad Ebadi\")\n",
    "employee_1.set_salary(50000)\n",
    "print(employee_1.name)\n",
    "print(employee_1.salary)\n",
    "employee_1.increase_salary(50000)\n",
    "print(employee_1.salary)\n",
    "\n",
    "# employee_2 = Employee()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8ba38d1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Javad Ebadi\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Employee' object has no attribute 'salary'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-ebfb02ead895>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m# employee_1.set_salary(50000)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0memployee_1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0memployee_1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msalary\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'Employee' object has no attribute 'salary'"
     ]
    }
   ],
   "source": [
    "employee_1 = Employee()\n",
    "employee_1.set_name(\"Javad Ebadi\")\n",
    "# employee_1.set_salary(50000)\n",
    "print(employee_1.name)\n",
    "print(employee_1.salary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9be40cd4",
   "metadata": {},
   "source": [
    "## class Constructor\n",
    "Class constructor is a method which will be called everytime a new object is created. In python, the special `__init__` method is the constructor.\n",
    "\n",
    "The `__init__` method is a good place to define the attributes of the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c2f50c33",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    def __init__(self, name=\"\", salary=0):\n",
    "        self.name = name\n",
    "        if salary >= 0:\n",
    "            self.salary = salary\n",
    "        else:\n",
    "#             raise ValueError(\"The salary could not be a negative number\")\n",
    "            self.salary = 0\n",
    "    \n",
    "    def set_name(self, new_name):\n",
    "        self.name = new_name\n",
    "        \n",
    "    def set_salary(self, new_salary):\n",
    "        self.salary = new_salary\n",
    "        \n",
    "    def increase_salary(self, amount):\n",
    "        self.salary += amount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "47702adb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Javad Ebadi\n",
      "50000\n"
     ]
    }
   ],
   "source": [
    "employee_1 = Employee(name=\"Javad Ebadi\", salary=50000)\n",
    "print(employee_1.name)\n",
    "print(employee_1.salary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "97d5418e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "employee_1 = Employee(name=\"Javad Ebadi\", salary=-1)\n",
    "print(employee_1.salary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3489537",
   "metadata": {},
   "source": [
    "## Class level attributes and instance level attributes\n",
    "\n",
    "Class level data is shared among all instances of the class and even it exists without creating an object.        \n",
    "\n",
    "In python, class level attributes are defined insided class, and outsided of any mehtods.\n",
    "\n",
    "```Python\n",
    "class Employee:\n",
    "    MAX_SALARY = 1000000  # maximum salary for an employee\n",
    "    MIN_SALARY = 27000  # minimun salary for an employee\n",
    "```\n",
    "\n",
    "The `MAX_SALARY` and `MIN_SALARY` attributes are class level attributes.\n",
    "\n",
    "To refer to class level attributes such as `MAX_SALARY` inside the class, we could NOT use. `self.MAX_SALARY` and instead of that we must use ClassName.CLASS_LEVEL_ATTRIBUTE such as `Employee.MAX_SALARY`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e1b54287",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAX_SALARY of employee 1 = 1000000\n",
      "MAX_SALARY of employee 2 = 1000000\n",
      "Employee MAX_SALARY = 1000000\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    \n",
    "    MAX_SALARY = 1000000  # class level attribute for maximum salary\n",
    "    MIN_SALARY = 27000  # class level attribute for minimum salary\n",
    "    \n",
    "    def __init__(self, name=\"\", salary=0):\n",
    "        self.name = name\n",
    "        self.set_salary(salary)\n",
    "    \n",
    "    def set_name(self, new_name):\n",
    "        self.name = new_name\n",
    "        \n",
    "    def set_salary(self, salary):\n",
    "        if salary <= Employee.MAX_SALARY and salary >= Employee.MIN_SALARY:\n",
    "            self.salary = salary\n",
    "        else:\n",
    "            raise ValueError(\n",
    "                f\"Employe salary must be between \"\n",
    "                f\"({Employee.MIN_SALARY}, {Employee.MAX_SALARY})\"\n",
    "            )\n",
    "        \n",
    "        \n",
    "    def increase_salary(self, amount):\n",
    "        self.salary += amount\n",
    "        \n",
    "\n",
    "employee_1 = Employee(\"John Smith\", 28000)\n",
    "employee_2 = Employee(\"Albert Einstien\", 60000)\n",
    "print(f\"MAX_SALARY of employee 1 = {employee_1.MAX_SALARY}\")\n",
    "print(f\"MAX_SALARY of employee 2 = {employee_2.MAX_SALARY}\")\n",
    "print(f\"Employee MAX_SALARY = {Employee.MAX_SALARY}\")\n",
    "# print(f\"Employee MAX_SALARY = {Employee.salary}\")  # this should raise AttributeError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9d589f3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAX_SALARY of employee 1 = 1000000\n",
      "MAX_SALARY of employee 2 = 1000000\n",
      "Employee MAX_SALARY = 1000000\n",
      "MAX_SALARY of employee 1 = 7777777\n",
      "MAX_SALARY of employee 2 = 1000000\n",
      "Employee MAX_SALARY = 1000000\n"
     ]
    }
   ],
   "source": [
    "print(f\"MAX_SALARY of employee 1 = {employee_1.MAX_SALARY}\")\n",
    "print(f\"MAX_SALARY of employee 2 = {employee_2.MAX_SALARY}\")\n",
    "print(f\"Employee MAX_SALARY = {Employee.MAX_SALARY}\")\n",
    "employee_1.MAX_SALARY = 7777777\n",
    "print(f\"MAX_SALARY of employee 1 = {employee_1.MAX_SALARY}\")\n",
    "print(f\"MAX_SALARY of employee 2 = {employee_2.MAX_SALARY}\")\n",
    "print(f\"Employee MAX_SALARY = {Employee.MAX_SALARY}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c01f5691",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAX_SALARY of employee 1 = 7777777\n",
      "MAX_SALARY of employee 2 = 7777777\n",
      "Employee MAX_SALARY = 7777777\n"
     ]
    }
   ],
   "source": [
    "Employee.MAX_SALARY = 7777777\n",
    "print(f\"MAX_SALARY of employee 1 = {employee_1.MAX_SALARY}\")\n",
    "print(f\"MAX_SALARY of employee 2 = {employee_2.MAX_SALARY}\")\n",
    "print(f\"Employee MAX_SALARY = {Employee.MAX_SALARY}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4178d8d",
   "metadata": {},
   "source": [
    "## Alternative constructors\n",
    "\n",
    "Python allows us to define class methods as well, using the `@classmethod` decorator and a special first argument `cls`. The main use of class methods is defining methods that return an instance of the class, but aren't using the same code as `__init__()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a984916f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    \n",
    "    MAX_SALARY = 1000000  # class level attribute for maximum salary\n",
    "    MIN_SALARY = 27000  # class level attribute for minimum salary\n",
    "    \n",
    "    def __init__(self, name=\"\", salary=0):\n",
    "        self.name = name\n",
    "        self.set_salary(salary)\n",
    "    \n",
    "    def set_name(self, new_name):\n",
    "        self.name = new_name\n",
    "        \n",
    "    def set_salary(self, salary):\n",
    "        if salary <= Employee.MAX_SALARY and salary >= Employee.MIN_SALARY:\n",
    "            self.salary = salary\n",
    "        else:\n",
    "            raise ValueError(\n",
    "                f\"Employe salary must be between \"\n",
    "                f\"({Employee.MIN_SALARY}, {Employee.MAX_SALARY})\"\n",
    "            )\n",
    "            \n",
    "    @classmethod\n",
    "    def from_dict(cls, employee_info):\n",
    "        name = employee_info[\"name\"]\n",
    "        salary = int(employee_info[\"salary\"])\n",
    "        return cls(name=name, salary=salary)\n",
    "\n",
    "        \n",
    "    def increase_salary(self, amount):\n",
    "        self.salary += amount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a017ad6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "employee_info = {\n",
    "    \"name\": \"John Smith\",\n",
    "    \"salary\": \"65000\",\n",
    "}\n",
    "employee_1 = Employee.from_dict(employee_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ac85cfd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name = John Smith\n",
      "Salary = 65000\n"
     ]
    }
   ],
   "source": [
    "print(f\"Name = {employee_1.name}\")\n",
    "print(f\"Salary = {employee_1.salary}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7a1d258",
   "metadata": {},
   "source": [
    "## Inheritance\n",
    "\n",
    "Inheritance means creating a new class by extending functionalities of an existing class.      \n",
    "\n",
    "We defined `Employee` class. Now, in organizations there are persons which are __managers__ of groups. Managers are still employees but they have some more responsibilites. Therefore, in programming we define `Manager` class which is inherited from `Employee` class.    \n",
    "\n",
    "In this case, the `Employee` is called the **parent**, **base** or **super** class. The `Manager` which is inherited from `Employee` class is called **child** class or **sub-class**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "502a803d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Manager(Employee):\n",
    "    \n",
    "    def print_role(self):\n",
    "        print(f\"Manager: {self.name}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f3bf4bc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "manager = Manager(name=\"Elon Musk\", salary=200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "328d4906",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manager name: Elon Musk\n",
      "Manage salary: 200000\n"
     ]
    }
   ],
   "source": [
    "print(f\"Manager name: {manager.name}\")\n",
    "print(f\"Manage salary: {manager.salary}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4addb5e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manager: Elon Musk\n"
     ]
    }
   ],
   "source": [
    "manager.print_role()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f2019db5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Manager"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(manager)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5286d8a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(manager, Manager)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "badbc7df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(manager, Employee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "80815f55",
   "metadata": {},
   "outputs": [],
   "source": [
    "employee = Employee(\"John Smith\", 28000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e8b721bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(employee, Employee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c7a59def",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(employee, Manager)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfe5c12f",
   "metadata": {},
   "source": [
    "## Inheritance - customized functionalities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "243a185e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    \n",
    "    MAX_SALARY = 1000000  # class level attribute for maximum salary\n",
    "    MIN_SALARY = 27000  # class level attribute for minimum salary\n",
    "    \n",
    "    def __init__(self, name=\"\", salary=0):\n",
    "        self.name = name\n",
    "        self.set_salary(salary)\n",
    "    \n",
    "    def set_name(self, new_name):\n",
    "        self.name = new_name\n",
    "        \n",
    "    def set_salary(self, salary):\n",
    "        if salary <= Employee.MAX_SALARY and salary >= Employee.MIN_SALARY:\n",
    "            self.salary = salary\n",
    "        else:\n",
    "            raise ValueError(\n",
    "                f\"Employe salary must be between \"\n",
    "                f\"({Employee.MIN_SALARY}, {Employee.MAX_SALARY})\"\n",
    "            )\n",
    "            \n",
    "    @classmethod\n",
    "    def from_dict(cls, employee_info):\n",
    "        name = employee_info[\"name\"]\n",
    "        salary = int(employee_info[\"salary\"])\n",
    "        return cls(name=name, salary=salary)\n",
    "\n",
    "        \n",
    "    def increase_salary(self, amount):\n",
    "        self.salary += amount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b55b2d28",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Manager(Employee):\n",
    "    MIN_SALARY = 50000\n",
    "    \n",
    "    def __init__(self, name, salary=50000, project=None):\n",
    "        Employee.__init__(self, name, salary)\n",
    "        self.project = project\n",
    "        \n",
    "    def increase_salary(self, amount, bonus=1.2):\n",
    "        Employee.increase_salary(self, amount*bonus)\n",
    "        \n",
    "    def print_role(self):\n",
    "        print(f\"Manager: {self.name}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c6897254",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee : 27000\n",
      "Manager : 50000\n"
     ]
    }
   ],
   "source": [
    "employee = Employee(\"John Smith\", 28000)\n",
    "manager = Manager(\"Elon Musk\", 200000)\n",
    "print(f\"Employee : {employee.MIN_SALARY}\")\n",
    "print(f\"Manager : {manager.MIN_SALARY}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "64e224f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manager salary: 200000\n",
      "Manager project: SpaceX\n"
     ]
    }
   ],
   "source": [
    "manager = Manager(\"Elon Musk\", 200000, \"SpaceX\")\n",
    "print(f\"Manager salary: {manager.salary}\")\n",
    "print(f\"Manager project: {manager.project}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "2b74fb12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee salary before increment: 60000\n",
      "Manager salary before increment: 60000\n",
      "Employee salary after increment: 70000\n",
      "Manager salary after increment: 72000.0\n"
     ]
    }
   ],
   "source": [
    "employee = Employee(\"John Smith\", 60000)\n",
    "manager = Manager(\"Elon Musk\", 60000, \"SpaceX\")\n",
    "print(f\"Employee salary before increment: {employee.salary}\")\n",
    "print(f\"Manager salary before increment: {manager.salary}\")\n",
    "employee.increase_salary(10000)\n",
    "manager.increase_salary(10000)\n",
    "print(f\"Employee salary after increment: {employee.salary}\")\n",
    "print(f\"Manager salary after increment: {manager.salary}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40c75b56",
   "metadata": {},
   "source": [
    "## Operator Overloading\n",
    "\n",
    "In Python, we can use operator overloading to give new meanings for operators such as `==`, `>`, `>=`, `<`, `<=`, `!=` and etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b610c2c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    \n",
    "    MAX_SALARY = 1000000  # class level attribute for maximum salary\n",
    "    MIN_SALARY = 27000  # class level attribute for minimum salary\n",
    "    \n",
    "    def __init__(self, name=\"\", salary=0):\n",
    "        self.name = name\n",
    "        self.set_salary(salary)\n",
    "    \n",
    "    def set_name(self, new_name):\n",
    "        self.name = new_name\n",
    "        \n",
    "    def set_salary(self, salary):\n",
    "        if salary <= Employee.MAX_SALARY and salary >= Employee.MIN_SALARY:\n",
    "            self.salary = salary\n",
    "        else:\n",
    "            raise ValueError(\n",
    "                f\"Employe salary must be between \"\n",
    "                f\"({Employee.MIN_SALARY}, {Employee.MAX_SALARY})\"\n",
    "            )\n",
    "            \n",
    "    # overload == operator\n",
    "    def __eq__(self, other):\n",
    "        if self.name == other.name and self.salary == other.salary:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "        \n",
    "    # overload != opeartor\n",
    "    ...\n",
    "        \n",
    "    # overlaod > operator\n",
    "    def __gt__(self, other):\n",
    "        if self.salary > other.salary:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    \n",
    "    @classmethod\n",
    "    def from_dict(cls, employee_info):\n",
    "        name = employee_info[\"name\"]\n",
    "        salary = int(employee_info[\"salary\"])\n",
    "        return cls(name=name, salary=salary)\n",
    "        \n",
    "    def increase_salary(self, amount):\n",
    "        self.salary += amount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "72bc6a81",
   "metadata": {},
   "outputs": [],
   "source": [
    "employee_1 = Employee(\"John Smith\", 50000)\n",
    "employee_2 = Employee(\"John Smith\", 50000)\n",
    "employee_3 = Employee(\"John Smith\", 100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9964055a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "employee_1 == employee_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "95ee5d7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "employee_1 == employee_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "5636be85",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "employee_1 < employee_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "7077e3f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "employee_1 > employee_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "2b446a57",
   "metadata": {},
   "outputs": [],
   "source": [
    "class c1:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "    def __eq__(self, other):\n",
    "        if type(self) != type(other):\n",
    "            return False\n",
    "        if self.name == other.name:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "        \n",
    "class c2:\n",
    "    def __init__(self, name):\n",
    "        self.name = name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d95f7f54",
   "metadata": {},
   "outputs": [],
   "source": [
    "obj_1 = c1(\"John\")\n",
    "obj_2 = c2(\"John\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "9fd70e27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj_1 == obj_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "7ae398f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parent:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "    def __eq__(self, other):\n",
    "        if self.name == other.name:\n",
    "            print(\"Parent __eq__ is exectued\")\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "            \n",
    "class Child(Parent):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "    def __eq__(self, other):\n",
    "        if self.name == other.name:\n",
    "            print(\"Child __eq__ is exectued\")\n",
    "            return True\n",
    "        else:\n",
    "            return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "553a4e63",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = Parent(\"John\")\n",
    "c = Child(\"John\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "502aff19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parent __eq__ is exectued\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p == p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "c2cbc8b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Child __eq__ is exectued\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c == c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "37a48c29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Child __eq__ is exectued\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p == c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d2ee34d",
   "metadata": {},
   "source": [
    "## Operator Overloading: string representation\n",
    "\n",
    "There are two special methods in Python classes\n",
    "- `__str__`\n",
    "- `__repr__`    \n",
    "\n",
    "which can be used to achieve string representations for objects.\n",
    "\n",
    "When you use `print` function or `str` function for Python object, the `__str__` method of that object will be executed.   \n",
    "The goal of defining `__str__` for class is to give users of your class a user friendly information about objects which are created from that class.\n",
    "\n",
    "The `__repr__` method is used by `repr` function and also give information about object when you print the object in console **without** using `print` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "dd7dfb2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    \n",
    "    MAX_SALARY = 1000000  # class level attribute for maximum salary\n",
    "    MIN_SALARY = 27000  # class level attribute for minimum salary\n",
    "    \n",
    "    def __init__(self, name=\"\", salary=0):\n",
    "        self.name = name\n",
    "        self.set_salary(salary)\n",
    "    \n",
    "    def set_name(self, new_name):\n",
    "        self.name = new_name\n",
    "        \n",
    "    def set_salary(self, salary):\n",
    "        if salary <= Employee.MAX_SALARY and salary >= Employee.MIN_SALARY:\n",
    "            self.salary = salary\n",
    "        else:\n",
    "            raise ValueError(\n",
    "                f\"Employe salary must be between \"\n",
    "                f\"({Employee.MIN_SALARY}, {Employee.MAX_SALARY})\"\n",
    "            )\n",
    "            \n",
    "    def __str__(self):\n",
    "        return f\"Employee name: {self.name}\\nEmployee salary: {self.salary}\"\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"Employee('{self.name}', {self.salary})\"\n",
    "    \n",
    "    def increase_salary(self, amount):\n",
    "        self.salary += amount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "504a6f8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "employee = Employee(\"John Smith\", 50000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "a53b7e93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee name: John Smith\n",
      "Employee salary: 50000\n"
     ]
    }
   ],
   "source": [
    "print(employee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "35cb969e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Employee name: John Smith\\nEmployee salary: 50000'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(employee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "da04260a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Employee('John Smith', 50000)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "employee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "86b8564c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Employee('John Smith', 50000)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Employee('John Smith', 50000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e00b3551",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}