OOP - Corey.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 align=\"center\">Python OOP Tutorial 1: Classes and Instances </h3> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are going to create an Employee class which will have have regular methods, classmethods, staticmethods, subclasses, class variables etc. To begin with, classes allow us to logically group our data and functions in order to reuse and build upon. \n",
    "\n",
    "We are creating an Employee class with *attributes* such as first, last, and pay. Before delving deeper, there is a distinction between class and instance. Employee here is a class, and each employee &mdash; **emp_1** &mdash; created is an instance here. For example `emp_1 = Employee()` will be a unique instance of an _**Employee**_ class.\n",
    "\n",
    "We start with a special ``__init__`` method. When we create a method within class, they receive instance *self* as a first argument as per convention &mdash; you can call it selfish or selfless or whatever you fancy.\n",
    "\n",
    "To further clarify instance, `self.first = first` is same as `emp_1.first = 'Corey'` except that former would allow any value.\n",
    "\n",
    "- Method: A function associated with a class\n",
    "- Self: Imagine it as loopy pipeline connecting your class with methods (and instances and subclasses?)\n",
    "- Note: We need paranthesis when calling method, but not when calling instance variable such as email or pay."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "                                            \"\"\"Snippet 1\"\"\"\n",
    "class Employee:\n",
    "\n",
    "    def __init__(self, first, last, pay): \n",
    "        self.first = first #These are instance variables using self argument. Instance would be emp_1 and so. \n",
    "        self.last = last #For each instance, these are instance variables.\n",
    "        self.email = first + '.' + last + '@email.com'\n",
    "        self.pay = pay\n",
    "         \n",
    "    def fullname(self): #this is a method. Self is required in this.\n",
    "        return '{} {}'.format(self.first, self.last)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we create an employee here, instance &mdash; self &mdash; is passed automatically, and we just need to pass other agruments. Here ``__init__`` method will run automatically &mdash; `emp_1` will be passed as `self` and then all atributes such as `emp_1.first = first` will be set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Corey.Schafer@email.com\n",
      "60000\n"
     ]
    }
   ],
   "source": [
    "emp_1 = Employee('Corey', 'Schafer', 50000)\n",
    "emp_2 = Employee('Test', 'Employee', 60000)\n",
    "print(emp_1.email)\n",
    "print(emp_2.pay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have setup our class, we want to add more functionality such as getting fullname. \n",
    "In order to so, we are going to create a method *fullname*. Each method within a class automatically takes the \n",
    "instance as a first argument and we are always going to call that `self`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Corey Schafer\n",
      "Corey Schafer\n"
     ]
    }
   ],
   "source": [
    "\"\"\"In this, we don't need to pass anything because instance emp_1 has already been instantiated. This essentially gets \n",
    "converted into the latter line in this cell.\"\"\"\n",
    "print(emp_1.fullname()) #we need paranthesis because it is a method, not an attribute.\n",
    "\n",
    "\"\"\"Since we are calling class name directly with method, we need to pass instance as an argument. \n",
    "Though, both are doing the same job.\"\"\"\n",
    "print(Employee.fullname(emp_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Common mistake: Not having self instance in a method\n",
    "Try removing __self__ from a fullname method, and we will get this error: `TypeError: fullname() takes 0 positional arguments but 1 was given`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 align=\"center\">Python OOP Tutorial 2: Class Variables </h3> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, we are going to create class variables which can be accessed by any instance in our class. For example, the company gives pay raises and that will be shared among all employees or instances.Instance variables are specific to an instance, or can be unique to those, whereas class variables are same for each instance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    \n",
    "    raise_amount = 1.04 #class variable with self \n",
    "    num_of_emps = 0 # class variable where isn't needed\n",
    "    \n",
    "    def __init__(self, first, last, pay):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.email = first + '.' + last + '@email.com'\n",
    "        self.pay = pay\n",
    "        \n",
    "        Employee.num_of_emps += 1 #within init method as it will keep getting populated everytime the class is called.\n",
    "\n",
    "    def fullname(self):\n",
    "        return '{} {}'.format(self.first, self.last)\n",
    "    \n",
    "    \"\"\"Since we hardcoded raise amount, it was difficult to access the raise factor, and there is no way to\n",
    "    update it either. Hence, raise_amount class variable was created.\"\"\"\n",
    "    def apply_raise(self): \n",
    "        self.pay = int(self.pay * 1.04)\n",
    "        \n",
    "    \"\"\"Although raise_amount is a class variable, we need self or Employee.raise_amount to access it\"\"\"    \n",
    "    def apply_raise1(self):  \n",
    "        self.pay = int(self.pay * self.raise_amount) \n",
    "        \n",
    "emp_1 = Employee('Corey', 'Schafer', 50000)\n",
    "emp_2 = Employee('Test', 'Employee', 60000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50000\n",
      "52000\n"
     ]
    }
   ],
   "source": [
    "# applying method to our pay\n",
    "print(emp_1.pay)\n",
    "emp_1.apply_raise() #same as Employee.apply_raise(emp_1) \n",
    "print(emp_1.pay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we are accessing attribute `raise_amount` on an instance &mdash; emp_1 and emp_2. If an instance doesn't have it, it will look into classes from where it is inheriting. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.04\n",
      "1.04\n",
      "1.04\n"
     ]
    }
   ],
   "source": [
    "# Accessing class variable from a class and instance\n",
    "print(Employee.raise_amount) \n",
    "print(emp_1.raise_amount) \n",
    "print(emp_2.raise_amount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'first': 'Corey', 'last': 'Schafer', 'email': 'Corey.Schafer@email.com', 'pay': 52000}\n",
      "{'__module__': '__main__', 'raise_amount': 1.04, 'num_of_emps': 2, '__init__': <function Employee.__init__ at 0x109170b70>, 'fullname': <function Employee.fullname at 0x1091700d0>, 'apply_raise': <function Employee.apply_raise at 0x109170f28>, 'apply_raise1': <function Employee.apply_raise1 at 0x109170ae8>, '__dict__': <attribute '__dict__' of 'Employee' objects>, '__weakref__': <attribute '__weakref__' of 'Employee' objects>, '__doc__': None}\n"
     ]
    }
   ],
   "source": [
    "#to check what happened in last three statements, let's print namespaces:\n",
    "print(emp_1.__dict__) #no raise_amount\n",
    "print(Employee.__dict__) #'raise_amount': 1.04"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.05\n",
      "1.05\n",
      "1.05\n"
     ]
    }
   ],
   "source": [
    "# let's say we want to change our raise amount to 1.05\n",
    "Employee.raise_amount = 1.05\n",
    "print(Employee.raise_amount) #Now when we print all of these, the amount would be 1.05 for class as well as instances.\n",
    "print(emp_1.raise_amount)\n",
    "print(emp_2.raise_amount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.04\n",
      "1.05\n",
      "1.04\n",
      "{'first': 'Corey', 'last': 'Schafer', 'email': 'Corey.Schafer@email.com', 'pay': 52000, 'raise_amount': 1.05}\n"
     ]
    }
   ],
   "source": [
    "Employee.raise_amount = 1.04 #setting back to old amount\n",
    "# What if we set raise_amount using an instance now\n",
    "emp_1.raise_amount = 1.05\n",
    "print(Employee.raise_amount) \n",
    "print(emp_1.raise_amount)\n",
    "print(emp_2.raise_amount)\n",
    "\n",
    "\"\"\"Now our instance namespace will have raise_amount attribute. Any apply_raise on emp_1 instance will first look\n",
    "for raise_amount in its own space first. Therefore, emp_2 still has class variable raise_amount of 1.04\"\"\"\n",
    "print(emp_1.__dict__) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52000\n",
      "54600\n"
     ]
    }
   ],
   "source": [
    "\"\"\"Since we increase only emp_1 instance pay, the new pay is 1.05 times. Also, we used self.raise_amount in our \n",
    "apply_raise1 method so when we instantiate, it looks into emp_1 namespace. Self in self.raise_amount gives us an\n",
    "ability to change the amount for a single instance, and will also allow subclasses to overwrite this raise amount.\"\"\"\n",
    "print(emp_1.pay) #\n",
    "emp_1.apply_raise1() \n",
    "print(emp_1.pay) # it will still be 52K or 1.04 times raise fo emp_2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to keep track of number of employees we have, and that number should be the same for all instances and therefore we don't have self for that. Instead of self, we have `Employee.num_of_emps` within our init method as we don't want this to be overwritten unlike our raise_amount."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(Employee.num_of_emps)\n",
    "emp_1 = Employee('Corey', 'Schafer', 50000)\n",
    "emp_2 = Employee('Test', 'Employee', 60000)\n",
    "print(Employee.num_of_emps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 align=\"center\">Python OOP Tutorial 3: classmethods and staticmethods </h3> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regular methods in a class automatically take instance  **self** as the first argument. Now we will start with classmethods which will take class as an argument and change the class variable. In order to create a classmethod, we use decorator @classmethod, which essentialy alters the functionality of our method. \n",
    "\n",
    "- Regular Methods: pass automatically instance as the first argument called 'self'\n",
    "- Class Methods: pass class as the first argument called 'cls'\n",
    "- Static Methods: pass automatically nothing. They are like functions with some logical connection to a class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "\n",
    "    num_of_emps = 0\n",
    "    raise_amt = 1.04\n",
    "\n",
    "    def __init__(self, first, last, pay):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.email = first + '.' + last + '@email.com'\n",
    "        self.pay = pay\n",
    "\n",
    "        Employee.num_of_emps += 1\n",
    "\n",
    "    def fullname(self):\n",
    "        return '{} {}'.format(self.first, self.last)\n",
    "\n",
    "    def apply_raise(self):\n",
    "        self.pay = int(self.pay * self.raise_amt)\n",
    "    \n",
    "    \n",
    "    \"\"\"Decorator classmethod.\n",
    "    'cls' is a convention like self for that argument. We have replaced self instance with class here.\"\"\"\n",
    "    @classmethod \n",
    "    def set_raise_amt(cls, amount):\n",
    "        cls.raise_amt = amount #this calls class variable and sets to desired raise amount.\n",
    "    \n",
    "    \n",
    "    \"\"\"We can also use our classmethods as alternative constructors to create multiple objects. They usually start with\n",
    "    'from' \"\"\"\n",
    "    @classmethod \n",
    "    def from_string(cls, emp_str): #alternative constructor which parses string.\n",
    "        first, last, pay = emp_str.split('-')\n",
    "        return cls(first, last, pay) #Using CLS or Employee class is same. We return so that we have an employee object\n",
    "    \n",
    "    \n",
    "    \"\"\"We use staticmethods when it doesn't depend on specifc class variable or an instance. In classmethods above, \n",
    "    we access CLS, or 'self' in regular methods. \"\"\"\n",
    "    @staticmethod #use it when you don't have to access class or an instance\n",
    "    def is_workday(day): \n",
    "        if day.weekday() == 5 or day.weekday() == 6:\n",
    "            return False\n",
    "        return True\n",
    "\n",
    "\n",
    "emp_1 = Employee('Corey', 'Schafer', 50000)\n",
    "emp_2 = Employee('Test', 'Employee', 60000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we call our classmethod, and set new raise_amt. Essentially, it is same as `employee.raise_amount = 1.05` in Tutorial 2. We can run classmethods from instances like this `emp_1.set_raise_amt(1.5)`, but that is futile and we don't need classmethod for that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.05\n",
      "1.05\n",
      "1.05\n"
     ]
    }
   ],
   "source": [
    "Employee.set_raise_amt(1.05)\n",
    "print(Employee.raise_amt)\n",
    "print(emp_1.raise_amt)\n",
    "print(emp_2.raise_amt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John.Doe@email.com\n",
      "30000\n",
      "Jane Doe\n"
     ]
    }
   ],
   "source": [
    "emp_str_1 = 'John-Doe-70000'\n",
    "emp_str_2 = 'Steve-Smith-30000'\n",
    "emp_str_3 = 'Jane-Doe-90000'\n",
    "\n",
    "new_emp_1 = Employee.from_string(emp_str_1)\n",
    "new_emp_2 = Employee.from_string(emp_str_2)\n",
    "new_emp_3 = Employee.from_string(emp_str_3)\n",
    "\n",
    "print(new_emp_1.email)\n",
    "print(new_emp_2.pay)\n",
    "print(new_emp_3.fullname())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "my_date = datetime.date(2016, 7, 11)\n",
    "\n",
    "print(Employee.is_workday(my_date)) #calling our staticmethod to check\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Regular Methods: fullname, apply_raise\n",
    "- Classmethods: set_raise_amount, from_string\n",
    "- Staticmethods: is_workday\n",
    "- Instances: emp_1, emp_2, dev_1\n",
    "- Instance Variables: self.first, self.last, self.pay"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 align=\"center\">Python OOP Tutorial 4: Inheritance - Creating Subclasses </h3> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee: \n",
    "\n",
    "    raise_amt = 1.04\n",
    "\n",
    "    def __init__(self, first, last, pay):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.email = first + '.' + last + '@email.com'\n",
    "        self.pay = pay\n",
    "\n",
    "    def fullname(self):\n",
    "        return '{} {}'.format(self.first, self.last)\n",
    "\n",
    "    def apply_raise(self):\n",
    "        self.pay = int(self.pay * self.raise_amt)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are going to create subclasses whcih allow us to inherit everything from parent class without affecting it. For example, we want to have different type of employees now -- Managers & developers. Both managers and developers have access to parent class instances such as name, email etc due to inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Developer(Employee): #this is inheriting everything from Employee class now\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev_1 = Developer('Corey', 'Schafer', 50000) #will function as our employee class did in previous examples.\n",
    "dev_2 = Developer('Test', 'Employee', 60000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Corey.Schafer@email.com\n",
      "Test.Employee@email.com\n"
     ]
    }
   ],
   "source": [
    "print(dev_1.email) \n",
    "print(dev_2.email)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using help function, we can see what developer subclass inherited from which class. Method Resolution Order shows that Python first checks Developer class to find init method, and then it goes to Employee class to find further, and lastly builtins objects. If you write Developer and look at autocomplete, you will see access to methods which Developer subclass has."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Developer in module __main__:\n",
      "\n",
      "class Developer(Employee)\n",
      " |  Method resolution order:\n",
      " |      Developer\n",
      " |      Employee\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods inherited from Employee:\n",
      " |  \n",
      " |  __init__(self, first, last, pay)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  apply_raise(self)\n",
      " |  \n",
      " |  fullname(self)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from Employee:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Employee:\n",
      " |  \n",
      " |  raise_amt = 1.04\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(help(Developer)) #this tells\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50000\n",
      "52000\n"
     ]
    }
   ],
   "source": [
    "print(dev_1.pay)\n",
    "dev_1.apply_raise()\n",
    "print(dev_1.pay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"If we want our developer class only to have a particular raise amount, we just need to provide \n",
    "it raise_amt instance. Also, run first cell in this tutorial before running this one\"\"\"\n",
    "\n",
    "class Developer(Employee): #this is inheriting everything from Employee class now\n",
    "    raise_amt = 1.10\n",
    "\n",
    "dev_1 = Developer('Corey', 'Schafer', 50000) \n",
    "dev_2 = Developer('Test', 'Employee', 60000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50000\n",
      "55000\n"
     ]
    }
   ],
   "source": [
    "print(dev_1.pay)\n",
    "dev_1.apply_raise()\n",
    "print(dev_1.pay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, for example we want to have our subclasses more information which parent class doesn't have. Let's say we want our Developer subclass have programming language. We will have now init method for our subclass. Since we want our employee class to handle first, last, and pay, we will class Employee class in our init method, or use `super()`. Another way would be to `Employee.__init__(self, first, last, pay)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Developer(Employee): \n",
    "    raise_amt = 1.10\n",
    "    \n",
    "    def __init__(self, first, last, pay, prog_lang):\n",
    "        super().__init__(first, last, pay) #this will pass instances to our Employee init method and let it handle.\n",
    "        self.prog_lang = prog_lang\n",
    "\n",
    "dev_1 = Developer('Corey', 'Schafer', 50000, 'Python')\n",
    "dev_2 = Developer('Test', 'Employee', 60000, 'Java')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n"
     ]
    }
   ],
   "source": [
    "print(dev_1.prog_lang)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are going to another class called Manager with a list of employees they manage as well as functionality &mdash; methods &mdash; to add and remove employees from a manager. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Manager(Employee):\n",
    "\n",
    "    def __init__(self, first, last, pay, employees=None):\n",
    "        super().__init__(first, last, pay) #inheriting from employee class.\n",
    "        if employees is None:\n",
    "            self.employees = [] \n",
    "        else:\n",
    "            self.employees = employees\n",
    "\n",
    "    def add_emp(self, emp):\n",
    "        if emp not in self.employees:\n",
    "            self.employees.append(emp)\n",
    "\n",
    "    def remove_emp(self, emp):\n",
    "        if emp in self.employees:\n",
    "            self.employees.remove(emp)\n",
    "\n",
    "    def print_emps(self):\n",
    "        for emp in self.employees:\n",
    "            print('-->', emp.fullname())\n",
    "\n",
    "dev_1 = Developer('Corey', 'Schafer', 50000, 'Python')\n",
    "dev_2 = Developer('Vishal', 'Kella', 60000, 'Java')\n",
    "\n",
    "mgr_1 = Manager('Sue', 'Smith', 90000, [dev_1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sue.Smith@email.com\n",
      "--> Vishal Kella\n"
     ]
    }
   ],
   "source": [
    "print(mgr_1.email)\n",
    "\n",
    "mgr_1.add_emp(dev_2)\n",
    "mgr_1.remove_emp(dev_1)\n",
    "\n",
    "mgr_1.print_emps()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Now we are going to to what is an instance/subclass of what?\n",
    "print(isinstance(mgr_1, Manager)) \n",
    "print(isinstance(mgr_1, Employee))\n",
    "print(isinstance(mgr_1, Developer)) \n",
    "print(issubclass(Manager, Employee))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, when we print it, it shows us our object only. Now we want to change that functionality using special methods in our next tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Developer object at 0x1091051d0>\n"
     ]
    }
   ],
   "source": [
    "print(dev_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 align=\"center\">Python OOP Tutorial 5: Special (Magic/Dunder) Methods </h3> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are going to use special methods to enhance our functionality &mdash; they are also called magic methods and allow us to emulate python builtin behavior. Also, `__` this before and after `init` method is called dunder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "\n",
    "    raise_amt = 1.04\n",
    "\n",
    "    def __init__(self, first, last, pay):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.email = first + '.' + last + '@email.com'\n",
    "        self.pay = pay\n",
    "\n",
    "    def fullname(self):\n",
    "        return '{} {}'.format(self.first, self.last)\n",
    "\n",
    "    def apply_raise(self):\n",
    "        self.pay = int(self.pay * self.raise_amt)\n",
    "\n",
    "    \n",
    "emp_1 = Employee('Corey', 'Schafer', 50000)\n",
    "emp_2 = Employee('Test', 'Employee', 60000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use two special methods here: `__repr__` and `__str__` . __repr__ is unambiguous representation of an object used for debugging, logging etc. It is targeted for developers. __str__ is a readable representation of an object meant for end-users. Essentially, the allow us to change the behaviour of our object when we print, for example `print(emp_1)` which just returns an object otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "   class Employee:\n",
    "\n",
    "    raise_amt = 1.04\n",
    "\n",
    "    def __init__(self, first, last, pay):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.email = first + '.' + last + '@email.com'\n",
    "        self.pay = pay\n",
    "\n",
    "    def fullname(self):\n",
    "        return '{} {}'.format(self.first, self.last)\n",
    "\n",
    "    def apply_raise(self):\n",
    "        self.pay = int(self.pay * self.raise_amt)\n",
    "\n",
    "    def __repr__(self): \n",
    "        return \"Employee('{}', '{}', {})\".format(self.first, self.last, self.pay)\n",
    "\n",
    "    def __str__(self): \n",
    "        return '{} - {}'.format(self.fullname(), self.email)\n",
    "\n",
    "    def __add__(self, other): #dunder to add salary.\n",
    "        return self.pay + other.pay\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.fullname())\n",
    "\n",
    "        \n",
    "emp_1 = Employee('Corey', 'Schafer', 50000)\n",
    "emp_2 = Employee('Test', 'Employee', 60000)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now when we print our object, It prints what is in our `__str__` method. `__repr__` is a fallback method for __str__. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Corey Schafer - Corey.Schafer@email.com\n"
     ]
    }
   ],
   "source": [
    "print(emp_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's comment out `__str__` and let's see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee('Corey', 'Schafer', 50000)\n"
     ]
    }
   ],
   "source": [
    "print(emp_1) #After repr, the result is the way we create our employee object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Corey Schafer - Corey.Schafer@email.com'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repr(emp_1) #print(emp_1) behind the hood is performing this: print(emp_1.__repr__ or __str__)\n",
    "str(emp_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now there are airthmetic and many other dunder methods which we can use. To illustrate, adding numbers or strings also calls dunder in python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n",
      "ab\n",
      "ab\n"
     ]
    }
   ],
   "source": [
    "print(1+2)\n",
    "print(int.__add__(1, 2)) #both doing same job\n",
    "\n",
    "print('a'+'b')\n",
    "print(str.__add__('a', 'b'))#both doing same job"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say we want to find total salary of two of our employees now. `__add__` dunder would be used for that with `self` as the first arguement which would be left side of addition, and `other` for the right side. There are many other methods on this link: https://docs.python.org/2.5/ref/numeric-types.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "110000\n"
     ]
    }
   ],
   "source": [
    "print(emp_1 + emp_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "print(len(emp_1))\n",
    "print(emp_1.__len__())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 align=\"center\">Python OOP Tutorial 6: Property Decorators - Getters, Setters, and Deleters </h3> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Property decorators allow us to use getters, setters, and deleters on our class attributes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "\n",
    "    def __init__(self, first, last):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.email = '{}.{}@email.com'.format(self.first, self.last)\n",
    "\n",
    "    def fullname(self):\n",
    "        return '{} {}'.format(self.first, self.last)\n",
    "\n",
    "\n",
    "emp_1 = Employee('John', 'Smith')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say that we change our emp_1 first name and then print everything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "emp_1.first = 'Jill'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jill\n",
      "John.Smith@email.com\n",
      "Jill Smith\n"
     ]
    }
   ],
   "source": [
    "print(emp_1.first)\n",
    "print(emp_1.email) #changing first name didn't change email. Fullname did change because it takes whatever is first.\n",
    "print(emp_1.fullname()) #remember parantheses because it is a method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To autoupdate our emails, we will use `@property` decorators. One might argue that we can create email method like we have our fullname method, but the problem with that is that it would break the code for everyone who is currently using the class, and will have to change the instance of email attribute with our new method. To autoupdate, getters, setters, and deleters will help."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "\n",
    "    def __init__(self, first, last):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "\n",
    "    @property #allows us to access email as an atribute instead of a method.\n",
    "    def email(self):\n",
    "        return '{}.{}@email.com'.format(self.first, self.last)\n",
    "\n",
    "    @property\n",
    "    def fullname(self):\n",
    "        return '{} {}'.format(self.first, self.last)\n",
    "\n",
    "\n",
    "emp_1 = Employee('John', 'Smith')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "John.Smith@email.com\n",
      "John Smith\n"
     ]
    }
   ],
   "source": [
    "print(emp_1.first)\n",
    "print(emp_1.email) #no use of parantheses because of @property decorator -- it is working like an attribute.\n",
    "print(emp_1.fullname)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we want user to provide just fullname, and let our class parmse first and last from that and udpate everything. If we try to set now, it will throw an `AttributeError`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-101-fb22feac8d71>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0memp_1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfullname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Vishal Kella'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "emp_1.fullname = 'Vishal Kella'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "\n",
    "    def __init__(self, first, last):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "\n",
    "    @property #allows us to access email as an atribute instead of a method.\n",
    "    def email(self):\n",
    "        return '{}.{}@email.com'.format(self.first, self.last)\n",
    "\n",
    "    @property\n",
    "    def fullname(self):\n",
    "        return '{} {}'.format(self.first, self.last)\n",
    "    \n",
    "    @fullname.setter\n",
    "    def fullname(self, name):\n",
    "        first, last = name.split(' ')\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "    \n",
    "    @fullname.deleter\n",
    "    def fullname(self):\n",
    "        print('Delete Name!')\n",
    "        self.first = None\n",
    "        self.last = None\n",
    "\n",
    "emp_1= Employee('Vishal', 'Kella')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vishal.Kella@email.com\n"
     ]
    }
   ],
   "source": [
    "print(emp_1.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Corey\n",
      "Schafer\n",
      "Corey.Schafer@email.com\n"
     ]
    }
   ],
   "source": [
    "emp_1.fullname = 'Corey Schafer' #setter allowed us to update everything.\n",
    "print(emp_1.first)\n",
    "print(emp_1.last)\n",
    "print(emp_1.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Delete Name!\n",
      "None\n",
      "None\n",
      "None.None@email.com\n"
     ]
    }
   ],
   "source": [
    "del emp_1.fullname\n",
    "print(emp_1.first)\n",
    "print(emp_1.last)\n",
    "print(emp_1.email)"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}