06-03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 14 - Classes and Methods\n",
    "\n",
    "## Week 6 Friday\n",
    "\n",
    "## Miles Chen, PhD\n",
    "\n",
    "Taken directly from Chapters 17 of Think Python by Allen B Downey"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Methods\n",
    "\n",
    "Methods are functions that are associated with a particular class.\n",
    "\n",
    "Methods are the same as functions, but there are two key differences:\n",
    "\n",
    "+ Methods are defined inside a class definition.\n",
    "+ The syntax for invoking a method is different from the syntax for calling a function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Revisiting The Time Class\n",
    "\n",
    "In the previous chapter/lecture we created a class `Time`.\n",
    "\n",
    "We also wrote a function called `print_time()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Time:\n",
    "    \"\"\"Represents the time of day.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def print_time(time):\n",
    "    print(\"%.2d:%.2d:%.2d\" % (time.hour, time.minute, time.second))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To call the function, we had to create a `Time` object and pass it as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:45:00\n"
     ]
    }
   ],
   "source": [
    "start = Time()\n",
    "start.hour = 9\n",
    "start.minute = 45\n",
    "start.second = 0\n",
    "print_time(start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Making a method\n",
    "\n",
    "To make print_time a method, all we have to do is move the function definition inside the class definition.\n",
    "\n",
    "Note the indentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Time:\n",
    "    def print_time(time):\n",
    "        print(\"%.2d:%.2d:%.2d\" % (time.hour, time.minute, time.second))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Now that we have redefined the class with a method defined inside, we can call the method.\n",
    "\n",
    "Note, I have to re-create start as a `Time` class object because the old start object was created under the old definition of class `Time`. The changes don't apply retroactively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "start = Time()\n",
    "start.hour = 9\n",
    "start.minute = 45\n",
    "start.second = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Calling the Method\n",
    "\n",
    "There are two ways to call a method, but in practice, most people use one.\n",
    "\n",
    "The less common way is to use the Class name and pass an object of that class to the method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:45:00\n"
     ]
    }
   ],
   "source": [
    "Time.print_time(start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The more common way is to call the method directly from the object itself using dot notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:45:00\n"
     ]
    }
   ],
   "source": [
    "start.print_time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "When you call a method from the object itself, the object is known as the **subject** of the method.\n",
    "\n",
    "The subject gets passed to the method as the first argument.\n",
    "\n",
    "So in our example above, the object `start` gets passed as the first argument in thge method `print_time()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `self`\n",
    "\n",
    "By convention, the first argument of a method is called `self`.\n",
    "\n",
    "The idea is that when you call a method from an object with dot notation, you are applying to function to itself.\n",
    "\n",
    "With this in mind, we'ld write our `Time` class as follows.\n",
    "\n",
    "I've also included another method that converts the time to number of seconds after midnight (time_to_int) which will be useful for adding times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Time:\n",
    "    def print_time(self):\n",
    "        print(\"%.2d:%.2d:%.2d\" % (self.hour, self.minute, self.second))\n",
    "        \n",
    "    def time_to_int(self):\n",
    "        minutes = self.hour * 60 + self.minute\n",
    "        seconds = minutes * 60 + self.second\n",
    "        return seconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# again, we redefine the object of class Time()\n",
    "start = Time()\n",
    "start.hour = 9\n",
    "start.minute = 45\n",
    "start.second = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:45:00\n"
     ]
    }
   ],
   "source": [
    "start.print_time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35100"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start.time_to_int()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We'll use the following function in the next class definition.\n",
    "\n",
    "It converts the number of seconds into a time.\n",
    "\n",
    "It can't be made as a method of a time object because the argument of this function is an integer value of seconds, and there is no object to invoke the method on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def int_to_time(seconds):\n",
    "    time = Time()\n",
    "    minutes, time.second = divmod(seconds, 60)\n",
    "    time.hour, time.minute = divmod(minutes, 60)\n",
    "    return time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Adding more methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Time:\n",
    "    def print_time(self):\n",
    "        print(\"%.2d:%.2d:%.2d\" % (self.hour, self.minute, self.second))\n",
    "        \n",
    "    def time_to_int(self):\n",
    "        minutes = self.hour * 60 + self.minute\n",
    "        seconds = minutes * 60 + self.second\n",
    "        return seconds\n",
    "    \n",
    "    def increment(self, seconds):\n",
    "        seconds += self.time_to_int()\n",
    "        return int_to_time(seconds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# again, we redefine the object of class Time()\n",
    "start = Time()\n",
    "start.hour = 9\n",
    "start.minute = 45\n",
    "start.second = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:45:00\n"
     ]
    }
   ],
   "source": [
    "start.print_time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10:07:17\n"
     ]
    }
   ],
   "source": [
    "end = start.increment(1337)\n",
    "end.print_time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Errors with method calls\n",
    "\n",
    "Keep in mind that when you call a method from an object, the object itself is always passed as the first argument of the method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "increment() takes 2 positional arguments but 3 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-a8fd8b8bdfbc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mend\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mstart\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mincrement\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1337\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m460\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: increment() takes 2 positional arguments but 3 were given"
     ]
    }
   ],
   "source": [
    "end = start.increment(1337, 460)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The above call returns an error. \"increment() takes 2 positional arguments but 3 were given\"\n",
    "\n",
    "It can be confusing because we see only two arguments (1337 and 460) in parentheses. We must remember that we have also passed `self` (the subject) as the first argument, so there really are three arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Methods with other class objects\n",
    "\n",
    "We can create a method inside `Time` called `is_after()` which will check to see if one time takes place after another time.\n",
    "\n",
    "This function takes in two `Time` class objects and compares them. I add this method to the end of our class definition.\n",
    "\n",
    "Because we expect the argument passed to `is_after()` is another `Time` class object, we can invoke the methods of the object. By convention, the first parameter of the method is `self`, and the parameter for the other class object being passed is named `other`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Time:\n",
    "    def print_time(self):\n",
    "        print(\"%.2d:%.2d:%.2d\" % (self.hour, self.minute, self.second))\n",
    "        \n",
    "    def time_to_int(self):\n",
    "        minutes = self.hour * 60 + self.minute\n",
    "        seconds = minutes * 60 + self.second\n",
    "        return seconds\n",
    "    \n",
    "    def increment(self, seconds):\n",
    "        seconds += self.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "    \n",
    "    def is_after(self, other):\n",
    "        return self.time_to_int() > other.time_to_int()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Calling the new method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:45:00\n"
     ]
    }
   ],
   "source": [
    "# redefine the objects\n",
    "start = Time()\n",
    "start.hour = 9\n",
    "start.minute = 45\n",
    "start.second = 0\n",
    "start.print_time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10:07:17\n"
     ]
    }
   ],
   "source": [
    "end = start.increment(1337)\n",
    "end.print_time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "end.is_after(start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start.is_after(end)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The `init` method\n",
    "\n",
    "It's been annoying that every time I redefine the `start` object, I have to assign the `hour`, `minute`, and `second` attributes.\n",
    "\n",
    "There is a special initialization method called `__init__` (also called double-under init) that gets invoked whenever a new object of the class is created.\n",
    "\n",
    "It is useful to use this method to assign values to attributes that would be used in the class. By convention, the parameters of init have the same names as the attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Time:\n",
    "    def __init__(self, hour = 0, minute = 0, second = 0):\n",
    "        self.hour = hour\n",
    "        self.minute = minute\n",
    "        self.second = second   \n",
    "    \n",
    "    def print_time(self):\n",
    "        print(\"%.2d:%.2d:%.2d\" % (self.hour, self.minute, self.second))\n",
    "        \n",
    "    def time_to_int(self):\n",
    "        minutes = self.hour * 60 + self.minute\n",
    "        seconds = minutes * 60 + self.second\n",
    "        return seconds\n",
    "    \n",
    "    def increment(self, seconds):\n",
    "        seconds += self.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "    \n",
    "    def is_after(self, other):\n",
    "        return self.time_to_int() > other.time_to_int()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Creating new `Time` class objects is much easier now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00:00:00\n"
     ]
    }
   ],
   "source": [
    "midnight = Time()\n",
    "midnight.print_time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:00:00\n"
     ]
    }
   ],
   "source": [
    "new_time = Time(9)\n",
    "new_time.print_time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The argument 9 gets passed in as the value for `hour` because `self` is always the first argument, even in the `__init__` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:45:00\n"
     ]
    }
   ],
   "source": [
    "new_time = Time(9, 45)\n",
    "new_time.print_time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The `__str__` method\n",
    "\n",
    "`__str__` is another special method that should return a string representation of an object.\n",
    "\n",
    "When you call `print()` on an object, Python invokes the `__str__` method.\n",
    "\n",
    "So far we have been using the method `print_time()` which we defined inside the class. \n",
    "\n",
    "Instead, we will modify this method to work with the `__str__` method. To view the time, we will call `print()` on the object.\n",
    "\n",
    "Note that in the conversion, we no longer call `print` but use `return` to return a string object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Time:\n",
    "    def __init__(self, hour = 0, minute = 0, second = 0):\n",
    "        self.hour = hour\n",
    "        self.minute = minute\n",
    "        self.second = second   \n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"%.2d:%.2d:%.2d\" % (self.hour, self.minute, self.second)\n",
    "        \n",
    "    def time_to_int(self):\n",
    "        minutes = self.hour * 60 + self.minute\n",
    "        seconds = minutes * 60 + self.second\n",
    "        return seconds\n",
    "    \n",
    "    def increment(self, seconds):\n",
    "        seconds += self.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "    \n",
    "    def is_after(self, other):\n",
    "        return self.time_to_int() > other.time_to_int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "new_time = Time(9, 45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "09:45:00\n"
     ]
    }
   ],
   "source": [
    "print(new_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operator overloading\n",
    "\n",
    "There are even more special \"double-under\" methods that have special uses.\n",
    "\n",
    "One is the `__add__` method which will be invoked with the `+` operator.\n",
    "\n",
    "I'll add the following method inside the class definition\n",
    "\n",
    "```\n",
    "\n",
    "    def __add__(self, other):\n",
    "        seconds += self.time_to_int() + other.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Time:\n",
    "    def __init__(self, hour = 0, minute = 0, second = 0):\n",
    "        self.hour = hour\n",
    "        self.minute = minute\n",
    "        self.second = second   \n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"%.2d:%.2d:%.2d\" % (self.hour, self.minute, self.second)\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        seconds = self.time_to_int() + other.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "    \n",
    "    def time_to_int(self):\n",
    "        minutes = self.hour * 60 + self.minute\n",
    "        seconds = minutes * 60 + self.second\n",
    "        return seconds\n",
    "    \n",
    "    def increment(self, seconds):\n",
    "        seconds += self.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "    \n",
    "    def is_after(self, other):\n",
    "        return self.time_to_int() > other.time_to_int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "start = Time(9, 45)\n",
    "duration = Time(1, 35)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11:20:00\n"
     ]
    }
   ],
   "source": [
    "print(start + duration)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Type-based dispatch\n",
    "\n",
    "The previous defintion of `__add__` allowed us to add two `Time` class objects together. But we might also want the option to add integers as well.\n",
    "\n",
    "We can use type-based dispatch to call different methods depending on the type of input. To perform this, we use the `isinstance()` to see if the object belongs to a particular class or not.\n",
    "\n",
    "Inside the class definition of Time, I'll add the following:\n",
    "\n",
    "~~~\n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, Time):\n",
    "            return self.add_time(other)\n",
    "        else:\n",
    "            return self.increment(other)\n",
    "\n",
    "    def add_time(self, other):\n",
    "        seconds = self.time_to_int() + other.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "        \n",
    "    def increment(self, seconds):\n",
    "        seconds += self.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Time:\n",
    "    def __init__(self, hour = 0, minute = 0, second = 0):\n",
    "        self.hour = hour\n",
    "        self.minute = minute\n",
    "        self.second = second   \n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"%.2d:%.2d:%.2d\" % (self.hour, self.minute, self.second)\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, Time):\n",
    "            return self.add_time(other)\n",
    "        else:\n",
    "            return self.increment(other)\n",
    "        \n",
    "    def time_to_int(self):\n",
    "        minutes = self.hour * 60 + self.minute\n",
    "        seconds = minutes * 60 + self.second\n",
    "        return seconds\n",
    "\n",
    "    def add_time(self, other):\n",
    "        seconds = self.time_to_int() + other.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "\n",
    "    def increment(self, seconds):\n",
    "        seconds += self.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "    \n",
    "    def is_after(self, other):\n",
    "        return self.time_to_int() > other.time_to_int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "start = Time(9, 45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "duration = Time(1, 35)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11:20:00\n"
     ]
    }
   ],
   "source": [
    "print(start + duration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10:07:17\n"
     ]
    }
   ],
   "source": [
    "print(start + 1337)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Commutative Addition\n",
    "\n",
    "The add method as we've implemented it is not commutative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'Time'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-44-f808e24131be>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1337\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstart\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'Time'"
     ]
    }
   ],
   "source": [
    "print(1337 + start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The problem is, instead of asking the Time object to add an integer, Python is asking an integer to add a Time object and it doesn't know how.\n",
    "\n",
    "If we want this to work, we have to use another special method: `__radd__` which stands for \"right-side add\"\n",
    "\n",
    "We can pull this off quite easily:\n",
    "\n",
    "~~~\n",
    "    def __radd__(self, other):\n",
    "        return self.__add__(other)\n",
    "~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Time:\n",
    "    def __init__(self, hour = 0, minute = 0, second = 0):\n",
    "        self.hour = hour\n",
    "        self.minute = minute\n",
    "        self.second = second   \n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"%.2d:%.2d:%.2d\" % (self.hour, self.minute, self.second)\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, Time):\n",
    "            return self.add_time(other)\n",
    "        else:\n",
    "            return self.increment(other)\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        return self.__add__(other)\n",
    "        \n",
    "    def time_to_int(self):\n",
    "        minutes = self.hour * 60 + self.minute\n",
    "        seconds = minutes * 60 + self.second\n",
    "        return seconds\n",
    "\n",
    "    def add_time(self, other):\n",
    "        seconds = self.time_to_int() + other.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "\n",
    "    def increment(self, seconds):\n",
    "        seconds += self.time_to_int()\n",
    "        return int_to_time(seconds)\n",
    "    \n",
    "    def is_after(self, other):\n",
    "        return self.time_to_int() > other.time_to_int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "start = Time(9, 45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "duration = Time(1, 35)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11:20:00\n"
     ]
    }
   ],
   "source": [
    "print(start + duration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10:07:17\n"
     ]
    }
   ],
   "source": [
    "print(start + 1337)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10:07:17\n"
     ]
    }
   ],
   "source": [
    "print(1337 + start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Polymorphism\n",
    "\n",
    "Many functions will work on different types. These are known as **polymorphic** functions.\n",
    "\n",
    "For example, the function `sum` can work on any object that support addition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "04:30:00\n"
     ]
    }
   ],
   "source": [
    "t1 = Time(1, 20)\n",
    "t2 = Time(1, 40)\n",
    "t3 = Time(1, 30)\n",
    "total = sum([t1, t2, t3])\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Important tips\n",
    "\n",
    "It is legal to add attributes to objects at any time. But if you have objects of the same type that don't have the same attributes, it can cause problems.\n",
    "\n",
    "It is recommended to initialize all of the objects attributes inside the `__init__` method.\n",
    "\n",
    "A useful function for debugging is teh `vars()` function which will print all of the attributes an object has as a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'hour': 9, 'minute': 45, 'second': 0}"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(start)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}