chapters/chap15.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1331faa1",
   "metadata": {},
   "source": [
    "You can order print and ebook versions of *Think Python 3e* from\n",
    "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n",
    "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3161b50b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from os.path import basename, exists\n",
    "\n",
    "def download(url):\n",
    "    filename = basename(url)\n",
    "    if not exists(filename):\n",
    "        from urllib.request import urlretrieve\n",
    "\n",
    "        local, _ = urlretrieve(url, filename)\n",
    "        print(\"Downloaded \" + str(local))\n",
    "    return filename\n",
    "\n",
    "download('https://github.com/AllenDowney/ThinkPython/raw/v3/thinkpython.py');\n",
    "download('https://github.com/AllenDowney/ThinkPython/raw/v3/diagram.py');\n",
    "\n",
    "import thinkpython"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa22117f",
   "metadata": {},
   "source": [
    "# Classes and Methods\n",
    "\n",
    "Python is an **object-oriented language** -- that is, it provides features that support object-oriented programming, which has these defining characteristics:\n",
    "\n",
    "-   Most of the computation is expressed in terms of operations on objects.\n",
    "\n",
    "-   Objects often represent things in the real world, and methods often correspond to the ways things in the real world interact.\n",
    "\n",
    "-   Programs include class and method definitions.\n",
    "\n",
    "For example, in the previous chapter we defined a `Time` class that corresponds to the way people record the time of day, and we defined functions that correspond to the kinds of things people do with times.\n",
    "But there was no explicit connection between the definition of the `Time` class and the function definitions that follow.\n",
    "We can make the connection explicit by rewriting a function as a **method**, which is defined inside a class definition."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9857823a",
   "metadata": {},
   "source": [
    "## Defining methods\n",
    "\n",
    "In the previous chapter we defined a class named `Time` and wrote a function named `print_time` that displays a time of day."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ee093ca4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Time:\n",
    "    \"\"\"Represents the time of day.\"\"\"\n",
    "\n",
    "def print_time(time):\n",
    "    s = f'{time.hour:02d}:{time.minute:02d}:{time.second:02d}'\n",
    "    print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a89ddf58",
   "metadata": {},
   "source": [
    "To make `print_time` a method, all we have to do is move the function\n",
    "definition inside the class definition. Notice the change in\n",
    "indentation.\n",
    "\n",
    "At the same time, we'll change the name of the parameter from `time` to `self`.\n",
    "This change is not necessary, but it is conventional for the first parameter of a method to be named `self`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fd26a1bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Time:\n",
    "    \"\"\"Represents the time of day.\"\"\"    \n",
    "\n",
    "    def print_time(self):\n",
    "        s = f'{self.hour:02d}:{self.minute:02d}:{self.second:02d}'\n",
    "        print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8da4079c",
   "metadata": {},
   "source": [
    "To call this method, you have to pass a `Time` object as an argument.\n",
    "Here's the function we'll use to make a `Time` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5fc157ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_time(hour, minute, second):\n",
    "    time = Time()\n",
    "    time.hour = hour\n",
    "    time.minute = minute\n",
    "    time.second = second\n",
    "    return time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6ad4e12",
   "metadata": {},
   "source": [
    "And here's a `Time` instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "35acd8e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "start = make_time(9, 40, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbcd333",
   "metadata": {},
   "source": [
    "Now there are two ways to call `print_time`. The first (and less common)\n",
    "way is to use function syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f755081c",
   "metadata": {},
   "outputs": [],
   "source": [
    "Time.print_time(start)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2eb0847e",
   "metadata": {},
   "source": [
    "In this version, `Time` is the name of the class, `print_time` is the name of the method, and `start` is passed as a parameter.\n",
    "The second (and more idiomatic) way is to use method syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d6f91aec",
   "metadata": {},
   "outputs": [],
   "source": [
    "start.print_time()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c80c40f0",
   "metadata": {},
   "source": [
    "In this version, `start` is the object the method is invoked on, which is called the **receiver**, based on the analogy that invoking a method is like sending a message to an object.\n",
    "\n",
    "Regardless of the syntax, the behavior of the method is the same.\n",
    "The receiver is assigned to the first parameter, so inside the method, `self` refers to the same object as `start`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8deb6c34",
   "metadata": {},
   "source": [
    "## Another method\n",
    "\n",
    "Here's the `time_to_int` function from the previous chapter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "24c4c985",
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_to_int(time):\n",
    "    minutes = time.hour * 60 + time.minute\n",
    "    seconds = minutes * 60 + time.second\n",
    "    return seconds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "144e043f",
   "metadata": {},
   "source": [
    "And here's a version rewritten as a method.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "dde6f15f",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%add_method_to Time\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": "markdown",
   "id": "e3a721ab",
   "metadata": {},
   "source": [
    "The first line uses the special command `add_method_to`, which adds a method to a previously-defined class.\n",
    "This command works in a Jupyter notebook, but it is not part of Python, so it won't work in other environments.\n",
    "Normally, all methods of a class are inside the class definition, so they get defined at the same time as the class.\n",
    "But for this book, it is helpful to define one method at a time.\n",
    "\n",
    "As in the previous example, the method definition is indented and the name of the parameter is `self`.\n",
    "Other than that, the method is identical to the function.\n",
    "Here's how we invoke it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8943fa0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "start.time_to_int()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14565505",
   "metadata": {},
   "source": [
    "It is common to say that we \"call\" a function and \"invoke\" a method, but they mean the same thing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bc24683",
   "metadata": {},
   "source": [
    "## Static methods\n",
    "\n",
    "As another example, let's consider the `int_to_time` function.\n",
    "Here's the version from the previous chapter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8547b1c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def int_to_time(seconds):\n",
    "    minute, second = divmod(seconds, 60)\n",
    "    hour, minute = divmod(minute, 60)\n",
    "    return make_time(hour, minute, second)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b77c2a0",
   "metadata": {},
   "source": [
    "This function takes `seconds` as a parameter and returns a new `Time` object.\n",
    "If we transform it into a method of the `Time` class, we have to invoke it on a `Time` object.\n",
    "But if we're trying to create a new `Time` object, what are we supposed to invoke it on?\n",
    "\n",
    "We can solve this chicken-and-egg problem using a **static method**, which is a method that does not require an instance of the class to be invoked.\n",
    "Here's how we rewrite this function as a static method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b233669c",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%add_method_to Time\n",
    "\n",
    "    def int_to_time(seconds):\n",
    "        minute, second = divmod(seconds, 60)\n",
    "        hour, minute = divmod(minute, 60)\n",
    "        return make_time(hour, minute, second)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7e2e788",
   "metadata": {},
   "source": [
    "Because it is a static method, it does not have `self` as a parameter.\n",
    "To invoke it, we use `Time`, which is the class object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7e88f06b",
   "metadata": {},
   "outputs": [],
   "source": [
    "start = Time.int_to_time(34800)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2f4fd5a",
   "metadata": {},
   "source": [
    "The result is a new object that represents 9:40."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8c9f66b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "start.print_time()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6a18c76",
   "metadata": {},
   "source": [
    "Now that we have `Time.from_seconds`, we can use it to write `add_time` as a method.\n",
    "Here's the function from the previous chapter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c600d536",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_time(time, hours, minutes, seconds):\n",
    "    duration = make_time(hours, minutes, seconds)\n",
    "    seconds = time_to_int(time) + time_to_int(duration)\n",
    "    return int_to_time(seconds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e56da48",
   "metadata": {},
   "source": [
    "And here's a version rewritten as a method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c6fa0176",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%add_method_to Time\n",
    "\n",
    "    def add_time(self, hours, minutes, seconds):\n",
    "        duration = make_time(hours, minutes, seconds)\n",
    "        seconds = time_to_int(self) + time_to_int(duration)\n",
    "        return Time.int_to_time(seconds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b784a4ea",
   "metadata": {},
   "source": [
    "`add_time` has `self` as a parameter because it is not a static method.\n",
    "It is an ordinary method -- also called an **instance method**.\n",
    "To invoke it, we need a `Time` instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e17b2ad7",
   "metadata": {},
   "outputs": [],
   "source": [
    "end = start.add_time(1, 32, 0)\n",
    "print_time(end)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1c806a9",
   "metadata": {},
   "source": [
    "## Comparing Time objects\n",
    "\n",
    "As one more example, let's write `is_after` as a method.\n",
    "Here's the `is_after` function, which is a solution to an exercise in the previous chapter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "971eebbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_after(t1, t2):\n",
    "    return time_to_int(t1) > time_to_int(t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e7153e8",
   "metadata": {},
   "source": [
    "And here it is as a method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "90d7234d",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%add_method_to Time\n",
    "\n",
    "    def is_after(self, other):\n",
    "        return self.time_to_int() > other.time_to_int()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50815aec",
   "metadata": {},
   "source": [
    "Because we're comparing two objects, and the first parameter is `self`, we'll call the second parameter `other`.\n",
    "To use this method, we have to invoke it on one object and pass the\n",
    "other as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "19e3d639",
   "metadata": {},
   "outputs": [],
   "source": [
    "end.is_after(start)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf97e358",
   "metadata": {},
   "source": [
    "One nice thing about this syntax is that it almost reads like a question,\n",
    "\"`end` is after `start`?\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15a17fce",
   "metadata": {},
   "source": [
    "## The `__str__` method\n",
    "\n",
    "When you write a method, you can choose almost any name you want.\n",
    "However, some names have special meanings.\n",
    "For example, if an object has a method named `__str__`, Python uses that method to convert the object to a string.\n",
    "For example, here is a `__str__` method for a time object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f935a999",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%add_method_to Time\n",
    "\n",
    "    def __str__(self):\n",
    "        s = f'{self.hour:02d}:{self.minute:02d}:{self.second:02d}'\n",
    "        return s"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b056b729",
   "metadata": {},
   "source": [
    "This method is similar to `print_time`, from the previous chapter, except that it returns the string rather than printing it.\n",
    "\n",
    "You can invoke this method in the usual way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "61d7275d",
   "metadata": {},
   "outputs": [],
   "source": [
    "end.__str__()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76092a0c",
   "metadata": {},
   "source": [
    "But Python can also invoke it for you.\n",
    "If you use the built-in function `str` to convert a `Time` object to a string, Python uses the `__str__` method in the `Time` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b6dcc0c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "str(end)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a26caa8",
   "metadata": {},
   "source": [
    "And it does the same if you print a `Time` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6e1e6fb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(end)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97eb30c2",
   "metadata": {},
   "source": [
    "Methods like `__str__` are called **special methods**.\n",
    "You can identify them because their names begin and end with two underscores."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e01e9673",
   "metadata": {},
   "source": [
    "## The __init__ method\n",
    "\n",
    "The most special of the special methods is `__init__`, so-called because it initializes the attributes of a new object.\n",
    "An `__init__` method for the `Time` class might look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7ddcca8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%add_method_to Time\n",
    "\n",
    "    def __init__(self, hour=0, minute=0, second=0):\n",
    "        self.hour = hour\n",
    "        self.minute = minute\n",
    "        self.second = second"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ba624c3",
   "metadata": {},
   "source": [
    "Now when we instantiate a `Time` object, Python invokes `__init__`, and passes along the arguments.\n",
    "So we can create an object and initialize the attributes at the same time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "afd652c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "time = Time(9, 40, 0)\n",
    "print(time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55e0e296",
   "metadata": {},
   "source": [
    "In this example, the parameters are optional, so if you call `Time` with no arguments,\n",
    "you get the default values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "8a852588",
   "metadata": {},
   "outputs": [],
   "source": [
    "time = Time()\n",
    "print(time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bacb036d",
   "metadata": {},
   "source": [
    "If you provide one argument, it overrides `hour`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0ff75ace",
   "metadata": {},
   "outputs": [],
   "source": [
    "time = Time(9)\n",
    "print(time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37edb221",
   "metadata": {},
   "source": [
    "If you provide two arguments, they override `hour` and `minute`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b8e948bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "time = Time(9, 45)\n",
    "print(time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "277de217",
   "metadata": {},
   "source": [
    "And if you provide three arguments, they override all three default\n",
    "values.\n",
    "\n",
    "When I write a new class, I almost always start by writing `__init__`, which makes it easier to create objects, and `__str__`, which is useful for debugging."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94bbbd7d",
   "metadata": {},
   "source": [
    "## Operator overloading\n",
    "\n",
    "By defining other special methods, you can specify the behavior of\n",
    "operators on programmer-defined types. For example, if you define a\n",
    "method named `__add__` for the `Time` class, you can use the `+`\n",
    "operator on Time objects.\n",
    "\n",
    "Here is an `__add__` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0d140036",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%add_method_to Time\n",
    "\n",
    "    def __add__(self, other):\n",
    "        seconds = self.time_to_int() + other.time_to_int()\n",
    "        return Time.int_to_time(seconds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0221c9ad",
   "metadata": {},
   "source": [
    "We can use it like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "280acfce",
   "metadata": {},
   "outputs": [],
   "source": [
    "duration = Time(1, 32)\n",
    "end = start + duration\n",
    "print(end)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cc7866e",
   "metadata": {},
   "source": [
    "There is a lot happening when we run these three lines of code:\n",
    "\n",
    "* When we instantiate a `Time` object, the `__init__` method is invoked.\n",
    "\n",
    "* When we use the `+` operator with a `Time` object, its `__add__` method is invoked.\n",
    "\n",
    "* And when we print a `Time` object, its `__str__` method is invoked.\n",
    "\n",
    "Changing the behavior of an operator so that it works with programmer-defined types is called **operator overloading**.\n",
    "For every operator, like `+`, there is a corresponding special method, like `__add__`. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7299e62",
   "metadata": {},
   "source": [
    "## Debugging\n",
    "\n",
    "A `Time` object is valid if the values of `minute` and `second` are between `0` and `60` -- including `0` but not `60` -- and if `hour` is positive.\n",
    "Also, `hour` and `minute` should be integer values, but we might allow `second` to have a fraction part.\n",
    "Requirements like these are called **invariants** because they should always be true.\n",
    "To put it a different way, if they are not true, something has gone wrong.\n",
    "\n",
    "Writing code to check invariants can help detect errors and find their causes.\n",
    "For example, you might have a method like `is_valid` that takes a Time object and returns `False` if it violates an invariant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "6eb34442",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%add_method_to Time\n",
    "\n",
    "    def is_valid(self):\n",
    "        if self.hour < 0 or self.minute < 0 or self.second < 0:\n",
    "            return False\n",
    "        if self.minute >= 60 or self.second >= 60:\n",
    "            return False\n",
    "        if not isinstance(self.hour, int):\n",
    "            return False\n",
    "        if not isinstance(self.minute, int):\n",
    "            return False\n",
    "        return True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a10ad3db",
   "metadata": {},
   "source": [
    "Then, at the beginning of each method you can check the arguments to make sure they are valid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "57d86843",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%add_method_to Time\n",
    "\n",
    "    def is_after(self, other):\n",
    "        assert self.is_valid(), 'self is not a valid Time'\n",
    "        assert other.is_valid(), 'self is not a valid Time'\n",
    "        return self.time_to_int() > other.time_to_int()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7c78e9a",
   "metadata": {},
   "source": [
    "The `assert` statement evaluates the expression that follows. If the result is `True`, it does nothing; if the result is `False`, it causes an `AssertionError`.\n",
    "Here's an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "5452888b",
   "metadata": {},
   "outputs": [],
   "source": [
    "duration = Time(minute=132)\n",
    "print(duration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "56680d97",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%expect AssertionError\n",
    "\n",
    "start.is_after(duration)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18bd34ad",
   "metadata": {},
   "source": [
    "`assert` statements are useful because they distinguish code that deals with normal conditions from code that checks for errors."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58b86fbe",
   "metadata": {},
   "source": [
    "## Glossary\n",
    "\n",
    "**object-oriented language:**\n",
    "A language that provides features to support object-oriented programming, notably user-defined types.\n",
    "\n",
    "**method:**\n",
    "A function that is defined inside a class definition and is invoked on instances of that class.\n",
    "\n",
    "**receiver:**\n",
    "The object a method is invoked on.\n",
    "\n",
    "**static method:**\n",
    "A method that can be invoked without an object as receiver.\n",
    "\n",
    "**instance method:**\n",
    "A method that must be invoked with an object as receiver.\n",
    "\n",
    "**special method:**\n",
    "A method that changes the way operators and some functions work with an object.\n",
    "\n",
    "**operator overloading:**\n",
    "The process of using special methods to change the way operators with with user-defined types.\n",
    "\n",
    "**invariant:**\n",
    " A condition that should always be true during the execution of a program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "796adf5c",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3115ea33",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This cell tells Jupyter to provide detailed debugging information\n",
    "# when a runtime error occurs. Run it before working on the exercises.\n",
    "\n",
    "%xmode Verbose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25cd6888",
   "metadata": {},
   "source": [
    "### Ask a virtual assistant\n",
    "\n",
    "For more information about static methods, ask a virtual assistant:\n",
    "\n",
    "* \"What's the difference between an instance method and a static method?\"\n",
    "\n",
    "* \"Why are static methods called static?\"\n",
    "\n",
    "If you ask a virtual assistant to generate a static method, the result will probably begin with `@staticmethod`, which is a \"decorator\" that indicates that it is a static method.\n",
    "Decorators are not covered in this book, but if you are curious, you can ask a VA for more information.\n",
    "\n",
    "In this chapter we rewrote several functions as methods.\n",
    "Virtual assistants are generally good at this kind of code transformation.\n",
    "As an example, paste the following function into a VA and ask it, \"Rewrite this function as a method of the `Time` class.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "133d7679",
   "metadata": {},
   "outputs": [],
   "source": [
    "def subtract_time(t1, t2):\n",
    "    return time_to_int(t1) - time_to_int(t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc9f135b-e242-4ef6-83eb-8e028235c07b",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "In the previous chapter, a series of exercises asked you to write a `Date` class and several functions that work with `Date` objects.\n",
    "Now let's practice rewriting those functions as methods.\n",
    "\n",
    "1. Write a definition for a `Date` class that represents a date -- that is, a year, month, and day of the month.\n",
    "\n",
    "2. Write an `__init__` method that takes `year`, `month`, and `day` as parameters and assigns the parameters to attributes. Create an object that represents June 22, 1933.\n",
    "\n",
    "2. Write `__str__` method that uses an f-string to format the attributes and returns the result. If you test it with the `Date` you created, the result should be `1933-06-22`.\n",
    "\n",
    "3. Write a method called `is_after` that takes two `Date` objects and returns `True` if the first comes after the second. Create a second object that represents September 17, 1933, and check whether it comes after the first object.\n",
    "\n",
    "Hint: You might find it useful write a method called `to_tuple` that returns a tuple that contains the attributes of a `Date` object in year-month-day order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "3c9f3777-4869-481e-9f4e-4223d6028913",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1122620d-f3f6-4746-8675-13ce0b7f3ee9",
   "metadata": {
    "tags": []
   },
   "source": [
    "You can use these examples to test your solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "fd4b2521-aa71-45da-97eb-ce62ce2714ad",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "birthday1 = Date(1933, 6, 22)\n",
    "print(birthday1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "ee3f1294-cad1-406b-a574-045ad2b84294",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "birthday2 = Date(1933, 9, 17)\n",
    "print(birthday2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "ac093f7b-83cf-4488-8842-5c71bcfa35ec",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "birthday1.is_after(birthday2)  # should be False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "7e7cb5e1-631f-4b1e-874f-eb16d4792625",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "birthday2.is_after(birthday1)  # should be True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b92712d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a7f4edf8",
   "metadata": {
    "tags": []
   },
   "source": [
    "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n",
    "\n",
    "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n",
    "\n",
    "Code license: [MIT License](https://mit-license.org/)\n",
    "\n",
    "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}