Ch15-Overloading-Polymorphism.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More OOP, Operator Overloading and Polymorphism\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/rambasnet/FDSPython-Notebooks/blob/master/Ch15-Overloading-Polymorphism.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
    "\n",
    "\n",
    "http://openbookproject.net/thinkcs/python/english3e/even_more_oop.html\n",
    "\n",
    "## MyTime\n",
    "- class that records the time of day\n",
    "- provide `__init__` method so every instance is created with appropriate attributes and initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyTime:\n",
    "    \"\"\"MyTime class that keeps track of time of day\"\"\"\n",
    "    def __init__(self, hrs=0, mins=0, secs=0):\n",
    "        \"\"\" Creates a MyTime object initialized to hrs, mins, secs \"\"\"\n",
    "        self.hours = hrs\n",
    "        self.minutes = mins\n",
    "        self.seconds = secs\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"{:02}:{:02}:{:02}\".format(self.hours, self.minutes, self.seconds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "time1 = MyTime(11, 59, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11:59:03\n"
     ]
    }
   ],
   "source": [
    "print(time1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions can be pure and modifiers\n",
    "- what functions should be part of class or methods?\n",
    "- typically, all the functions that operate on or use attributes of class should be part of the class called methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## pure functions\n",
    "- pure functions do not have side effects, such as modifying parameters and global variables\n",
    "- similar to constant functions in C++ world\n",
    "- getter methods are pure functions\n",
    "- e.g.: see add_time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_time(t1, t2):\n",
    "    h = t1.hours + t2.hours\n",
    "    m = t1.minutes + t2.minutes\n",
    "    s = t1.seconds + t2.seconds\n",
    "\n",
    "    while s >= 60:\n",
    "        s -= 60\n",
    "        m += 1\n",
    "\n",
    "    while m >= 60:\n",
    "        m -= 60\n",
    "        h += 1\n",
    "\n",
    "    sum_t = MyTime(h, m, s)\n",
    "    return sum_t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12:26:05\n"
     ]
    }
   ],
   "source": [
    "current_time = MyTime(9, 50, 45)\n",
    "bread_time = MyTime(2, 35, 20)\n",
    "done_time = add_time(current_time, bread_time)\n",
    "print(done_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## modifiers\n",
    "- functions that modify the object(s) it gets as parameter(s)\n",
    "- setter methods are modifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function takes MyTime myT and secs to update myT\n",
    "def increment(myT, seconds):\n",
    "    myT.seconds += seconds\n",
    "    mins = myT.seconds//60\n",
    "    \n",
    "    myT.seconds = myT.seconds%60\n",
    "    myT.minutes += mins\n",
    "    \n",
    "    hours = myT.minutes//60\n",
    "    myT.hours += hours\n",
    "    myT.minutes = myT.minutes%60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:50:45\n"
     ]
    }
   ],
   "source": [
    "current_time = MyTime(9, 50, 45)\n",
    "print(current_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "increment(current_time, 60*60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10:50:45\n"
     ]
    }
   ],
   "source": [
    "print(current_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting increment() to a method\n",
    "- OOD prefers the functions that work with objects to be member of the class or methods\n",
    "- increment can be a useful method for MyTime class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyTime:\n",
    "    def __init__(self, hrs=0, mins=0, secs=0):\n",
    "        \"\"\" Create a new MyTime object initialized to hrs, mins, secs.\n",
    "           The values of mins and secs may be outside the range 0-59,\n",
    "           but the resulting MyTime object will be normalized.\n",
    "        \"\"\"\n",
    "        self.hours = hrs\n",
    "        self.minutes = mins\n",
    "        self.seconds = secs\n",
    "        \n",
    "        # Calculate total seconds to represent\n",
    "        self.__normalize()\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"{:02}:{:02}:{:02}\".format(self.hours, self.minutes, self.seconds)\n",
    "    \n",
    "    def to_seconds(self):\n",
    "        \"\"\" Return the number of seconds represented\n",
    "            by this instance\n",
    "        \"\"\"\n",
    "        return self.hours * 3600 + self.minutes * 60 + self.seconds\n",
    "    \n",
    "    def increment(self, seconds):\n",
    "        self.seconds += seconds\n",
    "        self.__normalize()\n",
    "        \n",
    "    # should be treated as private method\n",
    "    def __normalize(self):\n",
    "        totalsecs = self.to_seconds()\n",
    "        self.hours = totalsecs // 3600        # Split in h, m, s\n",
    "        leftoversecs = totalsecs % 3600\n",
    "        self.minutes = leftoversecs // 60\n",
    "        self.seconds = leftoversecs % 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# improved add_time function\n",
    "def add_time(t1, t2):\n",
    "    secs = t1.to_seconds() + t2.to_seconds()\n",
    "    return MyTime(0, 0, secs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12:26:05\n"
     ]
    }
   ],
   "source": [
    "# test add_time function\n",
    "current_time = MyTime(9, 50, 45)\n",
    "bake_time = MyTime(2, 35, 20)\n",
    "done_time = add_time(current_time, bake_time)\n",
    "print(done_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### similarly, add_time can be moved inside MyTime class as a method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyTime:\n",
    "    def __init__(self, hrs=0, mins=0, secs=0):\n",
    "        \"\"\" Create a new MyTime object initialized to hrs, mins, secs.\n",
    "           The values of mins and secs may be outside the range 0-59,\n",
    "           but the resulting MyTime object will be normalized.\n",
    "        \"\"\"\n",
    "        self.hours = hrs\n",
    "        self.minutes = mins\n",
    "        self.seconds = secs\n",
    "        # Calculate total seconds to represent\n",
    "        self.__normalize()\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"{:02}:{:02}:{:02}\".format(self.hours, self.minutes, self.seconds)\n",
    "    \n",
    "    def to_seconds(self):\n",
    "        \"\"\" Return the number of seconds represented\n",
    "            by this instance\n",
    "        \"\"\"\n",
    "        return self.hours * 3600 + self.minutes * 60 + self.seconds\n",
    "    \n",
    "    def increment(self, secs):\n",
    "        self.seconds += secs\n",
    "        self.__normalize()\n",
    "        \n",
    "    def __normalize(self):\n",
    "        totalsecs = self.to_seconds()\n",
    "        self.hours = totalsecs // 3600        # Split in h, m, s\n",
    "        leftoversecs = totalsecs % 3600\n",
    "        self.minutes = leftoversecs // 60\n",
    "        self.seconds = leftoversecs % 60\n",
    "        \n",
    "    def add_time(self, other):\n",
    "        return MyTime(0, 0, self.to_seconds() + other.to_seconds())\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12:26:05\n"
     ]
    }
   ],
   "source": [
    "# now let's use MyTime class and its methods again\n",
    "current_time = MyTime(9, 50, 45)\n",
    "bake_time = MyTime(2, 35, 20)\n",
    "done_time = current_time.add_time(bake_time)\n",
    "print(done_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## special methods / operator overloading\n",
    "- https://docs.python.org/3/reference/datamodel.html\n",
    "- how about t1 = t2 + t3 just like adding primitive types\n",
    "- \\+ operator appends two strings, but adds two integers or floats\n",
    "- the same operator has different meaning for different types called operator overloading\n",
    "- replace add_time with built-in special method `__add__` to overload + operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyTime:\n",
    "\n",
    "    def __init__(self, hrs=0, mins=0, secs=0):\n",
    "        \"\"\" Create a new MyTime object initialized to hrs, mins, secs.\n",
    "           The values of mins and secs may be outside the range 0-59,\n",
    "           but the resulting MyTime object will be normalized.\n",
    "        \"\"\"\n",
    "        self.hours = hrs\n",
    "        self.minutes = mins\n",
    "        self.seconds = secs\n",
    "        # Calculate total seconds to represent\n",
    "        self.__normalize()\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"{:02}:{:02}:{:02}\".format(self.hours, self.minutes, self.seconds)\n",
    "    \n",
    "    def to_seconds(self):\n",
    "        \"\"\" Return the number of seconds represented\n",
    "            by this instance\n",
    "        \"\"\"\n",
    "        return self.hours * 3600 + self.minutes * 60 + self.seconds\n",
    "    \n",
    "    def increment(self, secs):\n",
    "        self.seconds += secs\n",
    "        self.normalize()\n",
    "        \n",
    "    def __normalize(self):\n",
    "        totalsecs = self.to_seconds()\n",
    "        self.hours = totalsecs // 3600        # Split in h, m, s\n",
    "        leftoversecs = totalsecs % 3600\n",
    "        self.minutes = leftoversecs // 60\n",
    "        self.seconds = leftoversecs % 60\n",
    "        \n",
    "    def __add__(self, other):\n",
    "        return MyTime(0, 0, self.to_seconds() + other.to_seconds())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12:26:05\n"
     ]
    }
   ],
   "source": [
    "current_time = MyTime(9, 50, 45)\n",
    "bread_time = MyTime(2, 35, 20)\n",
    "done_time = current_time + bread_time # equivalent to: done_time = current_time.__add__(bread_time)\n",
    "print(done_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## add two points\n",
    "- overloading our Point class to be able to add two points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    \"\"\"\n",
    "    Point class represents and manipulates x,y coords\n",
    "    \"\"\"\n",
    "    count = 0\n",
    "    \n",
    "    def __init__(self, xx=0, yy=0):\n",
    "        \"\"\"Create a new point with given x and y coords\"\"\"\n",
    "        self.x = xx\n",
    "        self.y = yy\n",
    "        Point.count += 1\n",
    "        \n",
    "    def dist_from_origin(self):\n",
    "        import math\n",
    "        dist = math.sqrt(self.x**2+self.y**2)\n",
    "        return dist\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"({}, {})\".format(self.x, self.y)\n",
    "    \n",
    "    def move(self, xx, yy):\n",
    "        self.x = xx\n",
    "        self.y = yy\n",
    "        \n",
    "    def __add__(self, other):\n",
    "        x = self.x + other.x\n",
    "        y = self.y + other.y\n",
    "        return Point(x, y)\n",
    "    \n",
    "    def __mul__(self, other):\n",
    "        \"\"\"\n",
    "        computes dot product of two points\n",
    "        \"\"\"\n",
    "        return self.x * other.x + self.y * other.y\n",
    "    \n",
    "    def __rmul__(self, other):\n",
    "        \"\"\"\n",
    "        if the left operand is primitive type (int or float) \n",
    "        and the right operand is a Point, Python invokes __rmul__\n",
    "        which performs scalar multiplication\n",
    "        \"\"\"\n",
    "        return Point(other * self.x, other * self.y)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12, 12)\n",
      "48\n",
      "(8, 8)\n"
     ]
    }
   ],
   "source": [
    "p1 = Point(2, 2)\n",
    "p2 = Point(10, 10)\n",
    "p3 = p1 + p2\n",
    "print(p3)\n",
    "print(p1 * p3)\n",
    "print(4 * p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## some special methods\n",
    "```\n",
    "__del__(self)\n",
    "    - destructor - called when an instance is about to be destroyed\n",
    "    \n",
    "__str__(self)\n",
    "   - called by str(object)\n",
    "   - called by format() and print() functions to format and print string representation\n",
    "   - must return string representation of object\n",
    "\n",
    "__lt__(self, other)\n",
    "    x < y calls x.__lt__(y)\n",
    "\n",
    "__gt__(self, other)\n",
    "    x > y calls x.__gt__(y)\n",
    "   \n",
    "__eq__(self, other)\n",
    "    x == y calls x.__eq__(y)\n",
    "\n",
    "__ne__(self, other)\n",
    "__ge__(self, other) \n",
    "__le__(self, other)\n",
    "\n",
    "Emulating numeric types:\n",
    "__add__(self, other)\n",
    "__sub__(self, other)\n",
    "__mul__(self, other)\n",
    "__mod__(self, other)\n",
    "__truediv__(self, other)\n",
    "__pow__(self, other)\n",
    "__xor__(self, other)\n",
    "__or__(self, other)\n",
    "__and__(self, other)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "exercise 1: implement some relevant special methods for Point class and test them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "exercise 2: implement some relevant special methods for Triangle class defined in previous chapter and test them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Polymorphism\n",
    "- functions typically work on a specific type we pass as parameter\n",
    "- some functions we want to apply to many types, such as arithmetic operations + in previous example\n",
    "    - function template technqiue provided by C++\n",
    "- e.g., `multadd` operation (common in linear algebra) takes 3 arguments, it multiplies the first two and then adds the third\n",
    "- function like this that can take arguments with different types is called polymorphic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multadd(x, y, z):\n",
    "    return x * y + z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multadd(3, 2, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(11, 15)\n"
     ]
    }
   ],
   "source": [
    "p1 = Point(3, 4)\n",
    "p2 = Point(5, 7)\n",
    "print(multadd(2, p1, p2))\n",
    "# = (2*p1) + p2\n",
    "# = (6, 8) + (5, 7)\n",
    "# = (11, 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "44\n"
     ]
    }
   ],
   "source": [
    "print(multadd (p1, p2, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## duck typing rule - dynamic binding\n",
    "- duck test: \"If it walks like a duck and it quacks like a duck, then it must be a duck\" \n",
    "- to determine whether a function can be applied to a new type, we apply Python's fundamental rule of polymorphism, called duck typing rule: <em> if all of the operations inside the function can be applied to the type, the function can be applied to the type </em>\n",
    "- e.g.: https://en.wikipedia.org/wiki/Duck_typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Duck flying\n",
      "Airplane flying\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Whale' object has no attribute 'fly'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/4f/1pkkv7h960j42p0ppgk9n4ywjr6t_b/T/ipykernel_39211/679246680.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     23\u001b[0m \u001b[0mlift_off\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mduck\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# prints `Duck flying`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[0mlift_off\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mairplane\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# prints `Airplane flying`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m \u001b[0mlift_off\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwhale\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Throws the error `'Whale' object has no attribute 'fly'`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/var/folders/4f/1pkkv7h960j42p0ppgk9n4ywjr6t_b/T/ipykernel_39211/679246680.py\u001b[0m in \u001b[0;36mlift_off\u001b[0;34m(entity)\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;31m# polymorphism\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mlift_off\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mentity\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m     \u001b[0mentity\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfly\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m     \u001b[0;31m# only throws error if some entity doesn't have fly attribute during run-time!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m     \u001b[0;31m# statically typed languages such as C++ give compile time errors!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Whale' object has no attribute 'fly'"
     ]
    }
   ],
   "source": [
    "class Duck:\n",
    "    def fly(self):\n",
    "        print(\"Duck flying\")\n",
    "\n",
    "class Airplane:\n",
    "    def fly(self):\n",
    "        print(\"Airplane flying\")\n",
    "\n",
    "class Whale:\n",
    "    def swim(self):\n",
    "        print(\"Whale swimming\")\n",
    "\n",
    "# polymorphism\n",
    "def lift_off(entity):\n",
    "    entity.fly() \n",
    "    # only throws error if some entity doesn't have fly attribute during run-time!\n",
    "    # statically typed languages such as C++ give compile time errors! \n",
    "\n",
    "duck = Duck()\n",
    "airplane = Airplane()\n",
    "whale = Whale()\n",
    "\n",
    "lift_off(duck) # prints `Duck flying`\n",
    "lift_off(airplane) # prints `Airplane flying`\n",
    "lift_off(whale) # Throws the error `'Whale' object has no attribute 'fly'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}