20_OOP_5_ObjectOrientedProgramming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic OOP principles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Encapsulation\n",
    "---\n",
    "\n",
    "The most important principle of object orientation is **encapsulation**: \n",
    "- The idea that data inside the object should only be accessed through the object's methods.\n",
    "\n",
    "```python\n",
    "class Person:\n",
    "    def __init__(self, fname, lname):\n",
    "        self.fname = fname\n",
    "        self.lname = lname\n",
    "    \n",
    "    def email(self):\n",
    "        return \"{}.{}@email.com\".format(self.fname, self.lname)\n",
    "```\n",
    "\n",
    "- The `email` method is a good example of **encapsulation** philosophy. \n",
    "- Whenever we want to derive a new value from an action we call the method on the object. \n",
    "- It is considered a bad practice to retrieve the information from inside the object and write separate code to perform the action outside of the object.\n",
    "\n",
    "#### Why Encapsulation?\n",
    "- The functionality is defined in **one place and not in multiple places**.\n",
    "- It is defined in a logical place – the **place where the data is kept**.\n",
    "- Data inside our object is not modified unexpectedly by external code in a completely different part of our program.\n",
    "- When we use a method, we only need to know what result the method will produce. (abstraction)\n",
    "- We could switch to using another object which is completely different on the inside, and not have to change any code because both objects have the same interface.\n",
    "- If an object doesn't have an interface method which does what we want to do, we **SHOULD add a new method or update an existing one**.\n",
    "\n",
    "---\n",
    "- In Python, __encapsulation__ is not enforced by the language, \n",
    "- But to indicate that the variables are private, we begin its name with an underscore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Polymorphism\n",
    "---\n",
    "- Python is implicitly polymorphic.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x, y):\n",
    "    return x+y\n",
    "\n",
    "print(func(1,2))\n",
    "print(func(\"Hello \", \"World\"))\n",
    "print(func([1, 2, 3], [3, 4, 5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A():\n",
    "    def do_something(self):\n",
    "        print(\"From A\")\n",
    "\n",
    "class B():\n",
    "    def do_something(self):\n",
    "        print(\"From B\")\n",
    "\n",
    "a = A()\n",
    "b = B()\n",
    "for obj in (a, b):\n",
    "    obj.do_something()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A():\n",
    "    def do_something(self):\n",
    "        print(\"From A\")\n",
    "\n",
    "class B():\n",
    "    def do_something(self):\n",
    "        print(\"From B\")\n",
    "        \n",
    "def poly_imp(obj):\n",
    "    obj.do_something()\n",
    "a = A()\n",
    "b = B()\n",
    "poly_imp(a)\n",
    "poly_imp(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Relationships between objects\n",
    "\n",
    "In Python, there are two main types of relationships between classes: \n",
    "- composition\n",
    "- inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Composition\n",
    "\n",
    "- Composition is a way of aggregating objects together by making some objects attributes of other objects. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'description': 'Mathematics 1000', 'course_code': 'MAM1000W', 'credits': 1, 'department': <__main__.Department object at 0x7f1178655c18>}\n"
     ]
    }
   ],
   "source": [
    "class Department:\n",
    "    def __init__(self, name, department_code):\n",
    "        self.name = name\n",
    "        self.department_code = department_code\n",
    "        self.courses = {}\n",
    "\n",
    "    def add_course(self, description, course_code, credits):\n",
    "        self.courses[course_code] = Course(description, course_code, credits, self)\n",
    "        return self.courses[course_code]\n",
    "\n",
    "\n",
    "class Course:\n",
    "    def __init__(self, description, course_code, credits, department):\n",
    "        self.description = description\n",
    "        self.course_code = course_code\n",
    "        self.credits = credits\n",
    "        self.department = department\n",
    "\n",
    "\n",
    "maths_dept = Department(\"Mathematics and Applied Mathematics\", \"MAM\")\n",
    "mam1000w = maths_dept.add_course(\"Mathematics 1000\", \"MAM1000W\", 1)\n",
    "\n",
    "print(mam1000w.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance\n",
    "\n",
    "- Inheritance is a way of arranging objects in a hierarchy\n",
    "- The hierarchy is most general to the most specific. \n",
    "    - Animal (general) -> Dog (little specific) -> Labador (more specific) -> *Another breed of Labador*\n",
    "- An object which inherits from another object is considered to be a subtype of that object. \n",
    "- We can describe the relationship between two objects using the phrase IS-A, that relationship is **inheritance**.\n",
    "---\n",
    "- A __subclass__ or __child__ is class which inherits\n",
    "- The other class is its __superclass__ or __parent__ class. \n",
    "- We can refer to the most generic class at the base of a hierarchy as a base class.\n",
    "    - Animal (base class)\n",
    "    - Dog (subclass or child of Animal class or Parent class of Labador) \n",
    "    - Labador (subclass or child of Dog class)\n",
    "---\n",
    "- Inheritance can help us to represent objects which have some differences and some similarities in the way they work. \n",
    "- We can put all the functionality that the objects have in common in a base class, and then define one or more subclasses with their own custom functionality.\n",
    "---\n",
    "- Inheritance is also a way of **reusing existing code** easily. \n",
    "- If we already have a class which does almost what we want, we can create a subclass in which we partially override some of its behaviour, or perhaps add some new functionality.\n",
    "---\n",
    "**Syntax**\n",
    "```python\n",
    "class Parent:\n",
    "    pass\n",
    "class Child(Parent):\n",
    "    pass\n",
    "class AnotherChild(Child):\n",
    "    pass\n",
    "```\n",
    "---\n",
    "- While using inheritance, python has a MRO (Method Resolution Order).\n",
    "- While creating a instance, if the method is not found in derived class, it looks for it in parent class. This chain is known as MRO.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "\n",
    "    def __init__(self, first, last, pay):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.email = self.first + \".\" + self.last + \"@deerwalk.com\"\n",
    "\n",
    "    def fullname(self):\n",
    "        return \"{} {}\".format(self.first, self.last)\n",
    "\n",
    "class Developer(Employee):\n",
    "\n",
    "    def __init__(self, first, last, pay, prog_lang):\n",
    "        Employee.__init__(self, first, last, pay) # calls Employee initializer\n",
    "        self.prog_lang = prog_lang\n",
    "\n",
    "\n",
    "dev_1 = Developer(\"Sagar\", \"Giri\", 50000, \"Python\")\n",
    "dev_2 = Developer(\"Test\", \"User\", 60000, \"Java\")\n",
    "\n",
    "print(dev_1.__dict__)\n",
    "print(dev_2.__dict__)\n",
    "\n",
    "print(isinstance(dev_1, Developer))\n",
    "print(isinstance(dev_1, Employee))\n",
    "\n",
    "print(issubclass(Developer, Employee))\n",
    "print(issubclass(Employee, Developer))\n",
    "\n",
    "print(issubclass(Developer, object))\n",
    "print(issubclass(Employee, object))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class Employee:\n",
    "\n",
    "    def __init__(self, first, last, pay):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.email = self.first + \".\" + self.last + \"@deerwalk.com\"\n",
    "\n",
    "    def fullname(self):\n",
    "        return \"{} {}\".format(self.first, self.last)\n",
    "\n",
    "class Developer(Employee):\n",
    "\n",
    "    def __init__(self, first, last, pay, prog_lang):\n",
    "        super().__init__(first, last, pay) # calling super in python3 convention\n",
    "        self.prog_lang = prog_lang\n",
    "\n",
    "\n",
    "class Manager(Employee):\n",
    "\n",
    "    # here employees = None because it is a list and list is mutable. We never pass mutable data types as args\n",
    "    def __init__(self, first, last, pay, employees=None):\n",
    "        super().__init__(first, last, pay)\n",
    "        if employees is None:\n",
    "            self.employees = []\n",
    "        else:\n",
    "            self.employees = employees\n",
    "\n",
    "    def add_employee(self, emp):\n",
    "        if emp not in self.employees:\n",
    "            self.employees.append(emp)\n",
    "\n",
    "    def remove_employee(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(\"Sagar\", \"Giri\", 50000, \"Python\")\n",
    "dev_2 = Developer(\"Test\", \"User\", 60000, \"Java\")\n",
    "\n",
    "mgr_1 = Manager(\"Rudra\", \"Pandey\", 100000, [dev_1])\n",
    "print(mgr_1.__dict__)\n",
    "\n",
    "mgr_1.add_employee(dev_2)\n",
    "print(mgr_1.__dict__)\n",
    "\n",
    "print(\"Developers under mgr_1 under\")\n",
    "mgr_1.print_emps()\n",
    "\n",
    "mgr_1.remove_employee(dev_2)\n",
    "print(\"After Removing dev_2 under mgr_1\")\n",
    "mgr_1.print_emps()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise:\n",
    "\n",
    "#### Use inheritance concept to depict: *Animal (general) -> Dog (little specific) -> Labador (more specific)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Suppose we have Engineering Manager who is an Employee, Manager and also a Developer.\n",
    "- In this case, EM can inherit from Employee, Manager and a Developer depending on the use case\n",
    "\n",
    "**Syntax**\n",
    "```python\n",
    "class A: # parent\n",
    "    pass\n",
    "class B: # base\n",
    "    pass\n",
    "class C(A, B): # base that inherits from A and B\n",
    "    pass\n",
    "```\n",
    "---\n",
    "- If a class inherits from multiple classes which have completely different properties\n",
    "- But things get complicated if two parent classes implement the same method or attribute.\n",
    "- Confliction in MRO\n",
    "\n",
    "--- \n",
    "**Where things get complicated**\n",
    "- Classes B and C inherit from A \n",
    "- Class D inherits from B and C, \n",
    "- Both B and C have a method `do_something`, \n",
    "- which `do_something` will D inherit? \n",
    "- This ambiguity is known as the **diamond problem**\n",
    "- Class we would encounter this problem with the `__init__` method.\n",
    "---\n",
    "- Fortunately the super function knows how to deal gracefully with multiple inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class A:\n",
    "    def m(self):\n",
    "        print(\"m of A called\")\n",
    "\n",
    "class B(A):\n",
    "    def m(self):\n",
    "        print(\"m of B called\")\n",
    "    \n",
    "class C(A):\n",
    "    def m(self):\n",
    "        print(\"m of C called\")\n",
    "\n",
    "class D(B,C):\n",
    "    def m(self):\n",
    "        print(\"m of D called\")\n",
    "    \n",
    "x = D()\n",
    "# x.m() # Problem\n",
    "\n",
    "# print(D.mro())\n",
    "# print(C.mro())\n",
    "# print(B.mro())\n",
    "# print(A.mro())\n",
    "\n",
    "# Solution\n",
    "# A.m(x)\n",
    "# B.m(x)\n",
    "# C.m(x)\n",
    "# D.m(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Use Case: Need to call other methods of A, B, C from D ?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def m(self):\n",
    "        print(\"m of A called\")\n",
    "\n",
    "class B(A):\n",
    "    def m(self):\n",
    "        print(\"m of B called\")\n",
    "    \n",
    "class C(A):\n",
    "    def m(self):\n",
    "        print(\"m of C called\")\n",
    "\n",
    "class D(B,C):\n",
    "    def m(self):\n",
    "        print(\"m of D called\")\n",
    "        A.m(self)\n",
    "        B.m(self)\n",
    "        C.m(self)\n",
    "    \n",
    "x = D()\n",
    "x.m()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But, how can we cope with this situation:\n",
    "- if both m of B and m of C will have to call m of A as well. \n",
    "- We can remove **`A.m(self)`** from m in D But, still the code is bugy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def m(self):\n",
    "        print(\"m of A called\")\n",
    "\n",
    "class B(A):\n",
    "    def m(self):\n",
    "        print(\"m of B called\")\n",
    "        A.m(self)\n",
    "    \n",
    "class C(A):\n",
    "    def m(self):\n",
    "        print(\"m of C called\")\n",
    "        A.m(self)\n",
    "\n",
    "class D(B,C):\n",
    "    def m(self):\n",
    "        print(\"m of D called\")\n",
    "        B.m(self)\n",
    "        C.m(self)\n",
    "x = D()\n",
    "x.m() # m of A is called twice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The optimal and Pythonic way to solve the problem, which is the \"super\" function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def m(self):\n",
    "        print(\"m of A called\")\n",
    "\n",
    "class B(A):\n",
    "    def m(self):\n",
    "        print(\"m of B called\")\n",
    "        super().m()\n",
    "    \n",
    "class C(A):\n",
    "    def m(self):\n",
    "        print(\"m of C called\")\n",
    "        super().m()\n",
    "\n",
    "class D(B,C):\n",
    "    def m(self):\n",
    "        print(\"m of D called\")\n",
    "        super().m()\n",
    "\n",
    "x = D()\n",
    "x.m()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# We can know the MRO of each class as well\n",
    "print(D.mro())\n",
    "print(C.mro())\n",
    "print(B.mro())\n",
    "print(A.mro())\n",
    "print(object.mro())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replacing inheritance with composition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Learner:\n",
    "    def __init__(self):\n",
    "        self.classes = []\n",
    "\n",
    "    def enrol(self, course):\n",
    "        self.classes.append(course)\n",
    "\n",
    "\n",
    "class Teacher:\n",
    "    def __init__(self):\n",
    "        self.courses_taught = []\n",
    "\n",
    "    def assign_teaching(self, course):\n",
    "        self.courses_taught.append(course)\n",
    "\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, surname, number, learner=None, teacher=None):\n",
    "        self.name = name\n",
    "        self.surname = surname\n",
    "        self.number = number\n",
    "\n",
    "        self.learner = learner\n",
    "        self.teacher = teacher\n",
    "\n",
    "jane = Person(\"Jane\", \"Smith\", \"SMTJNX045\", Learner(), Teacher())\n",
    "jane.learner.enrol(\"a_postgrad_course\")\n",
    "jane.teacher.assign_teaching(\"an_undergrad_course\")\n",
    "\n",
    "print(jane.__dict__)\n",
    "print(jane.learner.__dict__)\n",
    "print(jane.teacher.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Abstract classes and interfaces\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Classes which can't be instantiated are abstract class or interface class\n",
    "- Built in Programming language like Java\n",
    "- They act as a template for our class\n",
    "- We inherit from them and override the methods\n",
    "- All the insides of the methods must be implemented in a subclass.\n",
    "- Interface and abstract class shouldn't have implementation of method and can't be instantiated\n",
    "---\n",
    "- In Python we can’t prevent anyone from instantiating a class\n",
    "- But, we can create something similar to an abstract class by using NotImplementedError inside our method definitions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Shape2D:\n",
    "    def area(self):\n",
    "        raise NotImplementedError() # We are raising an exception ourself, to prevent the function call\n",
    "\n",
    "class Shape3D:\n",
    "    def volume(self):\n",
    "        raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-478191d55e67>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ms1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mShape2D\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0ms2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mShape3D\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ms1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marea\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Will throw NotImplementedError exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-2-a718f06b5995>\u001b[0m in \u001b[0;36marea\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mShape2D\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0marea\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# We are raising an exception ourself, to prevent the function call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mShape3D\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "s1 = Shape2D()\n",
    "s2 = Shape3D()\n",
    "s1.area() # Will throw NotImplementedError exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Square(Shape2D):\n",
    "    def __init__(self, width):\n",
    "        self.width = width\n",
    "\n",
    "    def area(self):\n",
    "        return self.width ** 2\n",
    "\n",
    "class Cube(Shape3D):\n",
    "    def __init__(self, width):\n",
    "        self.width = width\n",
    "\n",
    "    def volume(self):\n",
    "        return self.width ** 3\n",
    "\n",
    "sq = Square(3)\n",
    "print(sq.area())\n",
    "\n",
    "cu = Cube(4)\n",
    "print(cu.volume())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}