reading-journal-09.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 9 Reading Journal\n",
    "\n",
    "Read _Think Python_, [Chapter 15](http://www.greenteapress.com/thinkpython2/html/thinkpython2016.html), [16](http://www.greenteapress.com/thinkpython2/html/thinkpython2017.html), [17](http://www.greenteapress.com/thinkpython2/html/thinkpython2018.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 15](http://www.greenteapress.com/thinkpython2/html/thinkpython2016.html) Classes and objects\n",
    "\n",
    "This chapter has very few (and short) exercises, and is more focused on starting to think about classes and objects. If you haven't seen user defined types like classes before, you should read closely and try out some examples on your own. For example, you can write a [Python Tutor example like this one](http://pythontutor.com/visualize.html#code=%23%20Example%20for%20visualizing%20object%20diagrams%20by%20stepping%20through%20the%20code%0A%0Aclass%20Point%28object%29%3A%0A%20%20%20%20%22%22%22Represents%20a%20point%20in%202-D%20space.%22%22%22%0A%20%20%20%20pass%0A%0Aclass%20Rectangle%28object%29%3A%0A%20%20%20%20%22%22%22Represents%20a%20rectangle.%20%0A%0A%20%20%20%20attributes%3A%20width,%20height,%20corner.%0A%20%20%20%20%22%22%22%0A%20%20%20%20pass%0A%0A%0A%23%20Create%20a%20point%20to%20serve%20as%20origin%20for%20our%20rectangles%0Ap%20%3D%20Point%28%29%0Ap.x%20%3D%2010%0Ap.y%20%3D%2015%0A%0A%23%20Create%20two%20rectangles%20with%20different%20size%0Ar1%20%3D%20Rectangle%28%29%0Ar1.corner%20%3D%20p%0Ar1.width%20%3D%20100%0Ar1.height%20%3D%20100%0A%0Ar2%20%3D%20Rectangle%28%29%0Ar2.corner%20%3D%20p%0Ar2.width%20%3D%2050%0Ar2.height%20%3D%20200%0A%0A%23%20Change%20the%20width%20of%20r2%20-%20what%20%28if%20any%29%20is%20the%20effect%20on%20r1%20and%20why%3F%0Ar2.width%20%3D%20150%0Aprint%28r1.width%29%0A%0A%23%20Change%20the%20corner%20position%20of%20r1%20-%20what%20%28if%20any%29%20is%20the%20effect%20on%20r2%20and%20why%3F%0Ar1.corner.x%20%3D%2020%0Aprint%28r2.corner.x%29&cumulative=false&curInstr=0&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) to explore object diagrams and aliasing.\n",
    "\n",
    "**Note**: The sequence of operations we use in this chapter to create class instances and assign their attributes, e.g. \n",
    "\n",
    "```python\n",
    "box = Rectangle()\n",
    "box.width = 100.0\n",
    "box.height = 200.0\n",
    "box.corner = Point()\n",
    "box.corner.x = 0.0\n",
    "box.corner.y = 0.0\n",
    "```\n",
    "\n",
    "is somewhat clumsy and error prone. Things will get better in the next couple chapters; feel free to look ahead if you'd like a sneak preview.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** In about one sentence using your own words, what is a class?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A class is a new \"type\", like a list, dictionary or tuple. It can store, recall, and set information. A user-defined type works a lot like objects we've already used, like turtle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 15.1"
   },
   "source": [
    "### Chapter 15.2  \n",
    "\n",
    "Write a function called `distance_between_points` that takes two `Points` as arguments and returns the distance between them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "solution": "Exercise 15.1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "class Point():\n",
    "    \"\"\"Is a point\"\"\"\n",
    "    \n",
    "point_A = Point()\n",
    "point_B = Point()\n",
    "\n",
    "point_A.x = 5\n",
    "point_A.y = 1\n",
    "point_B.x = 2\n",
    "point_B.y = -3\n",
    "\n",
    "def distance_between_points(point1,point2):\n",
    "    x_dist = abs(point2.x-point1.x)\n",
    "    y_dist = abs(point2.y-point1.y)\n",
    "    \n",
    "    total_dist = math.sqrt(x_dist**2+y_dist**2)\n",
    "    \n",
    "    return total_dist\n",
    "\n",
    "distance_between_points(point_A,point_B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 15.2"
   },
   "source": [
    "### Chapter 15.5\n",
    "\n",
    "Write a function named `move_rectangle` that takes a `Rectangle` and two numbers named `dx` and `dy`. It should change the location of the rectangle by adding `dx` to the `x` coordinate of `corner` and adding `dy` to the `y` coordinate of `corner`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "solution": "Exercise 15.2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 7\n"
     ]
    }
   ],
   "source": [
    "class Rectangle():\n",
    "    \"\"\"Is a rectangle\"\"\"\n",
    "    corner = Point()\n",
    "    corner.x = 0\n",
    "    corner.y = 0\n",
    "\n",
    "    \n",
    "rect = Rectangle()\n",
    "rect.length = 5\n",
    "rect.width = 3\n",
    "\n",
    "def move_rectangle(rectangle,dx,dy):\n",
    "    rectangle.corner.x += dx\n",
    "    rectangle.corner.y += dy\n",
    "    \n",
    "move_rectangle(rect,5,7)\n",
    "\n",
    "print(rect.corner.x, rect.corner.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 15.3"
   },
   "source": [
    "### Chapter 15.6\n",
    "\n",
    "Write a version of `move_rectangle` that creates and returns a new `Rectangle` instead of modifying the old one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "solution": "Exercise 15.3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 3 0 0\n",
      "5 3 5 7\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "class Rectangle(): # For some reason, this code block was acting weird without the definition of a Rectangle inside the block.\n",
    "    \"\"\"Is a rectangle\"\"\"\n",
    "\n",
    "lol_rect = Rectangle()\n",
    "lol_rect.length = 5\n",
    "lol_rect.width = 3\n",
    "lol_rect.corner = Point()\n",
    "lol_rect.corner.x = 0\n",
    "lol_rect.corner.y = 0\n",
    "\n",
    "def move_copy_rectangle(rect,dx,dy):\n",
    "    new_rect = copy.deepcopy(rect)\n",
    "    new_rect.corner.x += dx\n",
    "    new_rect.corner.y += dy\n",
    "\n",
    "    return new_rect\n",
    "    \n",
    "newer_rect = move_copy_rectangle(lol_rect,5,7)\n",
    "\n",
    "print(lol_rect.length, lol_rect.width, lol_rect.corner.x, lol_rect.corner.y)\n",
    "print(newer_rect.length, newer_rect.width, newer_rect.corner.x, newer_rect.corner.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 16](http://www.greenteapress.com/thinkpython2/html/thinkpython2017.html) Classes and functions\n",
    "\n",
    "Note: If you're confused about string formatting operations (e.g. `%.2d`) in the reading, you can check out [Think Python 14.3](http://greenteapress.com/thinkpython2/html/thinkpython2015.html#sec167) or the [PyFormat cheat sheet](https://pyformat.info/).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chapter 16.1  \n",
    "\n",
    "Write a boolean function called `is_after` that takes two `Time` objects, `t1` and `t2`, and returns `True` if `t1` follows `t2` chronologically and `False` otherwise. Challenge: don’t use an `if` statement. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class Time:\n",
    "    \"\"\"Represents the time of day.\n",
    "    \n",
    "    attributes: hour, minute, second\n",
    "    \"\"\"\n",
    "    \n",
    "time1 = Time()\n",
    "time1.hour = 11\n",
    "time1.minute = 59\n",
    "time1.second = 30\n",
    "\n",
    "time2 = Time()\n",
    "time2.hour = 11\n",
    "time2.minute = 59\n",
    "time2.second = 31\n",
    "\n",
    "time3 = Time()\n",
    "time3.hour = 10\n",
    "time3.minute = 31\n",
    "time3.second = 30\n",
    "\n",
    "time4 = Time()\n",
    "time4.hour = 9\n",
    "time4.minute = 59\n",
    "time4.second = 31\n",
    "\n",
    "def is_after(t1, t2):\n",
    "    if t1.hour > t2.hour:\n",
    "        return True\n",
    "    if t1.hour == t2.hour:\n",
    "        if t1.minute > t2.minute:\n",
    "            return True\n",
    "    if t1.hour == t2.hour:\n",
    "        if t1.minute == t2.minute:\n",
    "            if t1.second > t2.second:\n",
    "                return True\n",
    "    return False\n",
    "\n",
    "print(is_after(time1, time2))\n",
    "print(is_after(time3, time4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1  \n",
    "Write a function called `mul_time` that takes a `Time` object and a number and returns a new `Time` object that contains the product of the original `Time` and the number.\n",
    "\n",
    "Then use `mul_time` to write a function that takes a `Time` object that represents the finishing time in a race, and a number that represents the distance, and returns a `Time` object that represents the average pace (time per mile)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 48 31\n",
      "11 25 33\n",
      "\n",
      "3 48 31\n",
      "0 45 42\n"
     ]
    }
   ],
   "source": [
    "finish_time = Time()\n",
    "finish_time.hour = 3\n",
    "finish_time.minute = 48\n",
    "finish_time.second = 31\n",
    "\n",
    "def mul_time(t1, number):\n",
    "    multiplied_time = copy.deepcopy(t1)\n",
    "    seconds = multiplied_time.hour*3600 + multiplied_time.minute*60 + multiplied_time.second\n",
    "    seconds *= number\n",
    "    multiplied_time.hour = int(seconds/3600)\n",
    "    multiplied_time.minute = int(seconds%3600/60)\n",
    "    multiplied_time.second = int(seconds%3600%60)\n",
    "    return multiplied_time\n",
    "    \n",
    "new_time = mul_time(finish_time, 3)\n",
    "\n",
    "print(finish_time.hour, finish_time.minute, finish_time.second)\n",
    "print(new_time.hour, new_time.minute, new_time.second)\n",
    "print()\n",
    "\n",
    "def average_pace(t1, distance):\n",
    "    result = mul_time(t1, 1/distance)\n",
    "    return result\n",
    "\n",
    "res = average_pace(finish_time, 5)\n",
    "print(finish_time.hour, finish_time.minute, finish_time.second)\n",
    "print(res.hour, res.minute, res.second)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** Is `mul_time` a pure function or a modifier?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "mul_time is a modifier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 17](http://www.greenteapress.com/thinkpython2/html/thinkpython2018.html) Classes and methods\n",
    "\n",
    "In chapter 17 we finally have the tools to really put user-defined classes to work! In the exercises for this reading journal, we'll go back and add methods to your `Point` class from Chapter 15 to make it a lot easier to use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chapter 17.5 \n",
    "\n",
    "Write an init method for the `Point` class that takes `x` and `y` as optional parameters and assigns them to the corresponding attributes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n"
     ]
    }
   ],
   "source": [
    "class Point():\n",
    "    \"\"\"Is a point\"\"\"\n",
    "    def __init__(self, x=0, y=0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "blah = Point()\n",
    "\n",
    "print(blah.x,blah.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chapter 17.6\n",
    "\n",
    "Write a str method for the `Point` class. Create a `Point` object and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n"
     ]
    }
   ],
   "source": [
    "class Point():\n",
    "    \"\"\"Is a point\"\"\"\n",
    "    def __init__(self, x=0, y=0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def __str__(self, x=0, y=0):\n",
    "        return '%d %d' % (self.x, self.y)\n",
    "\n",
    "blah = Point()\n",
    "\n",
    "print(blah)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chapter 17.7  \n",
    "\n",
    "Write an add method for the `Point` class. Optional: implement operator overloading so that you can use the '+' operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "class Point():\n",
    "    \"\"\"Is a point\"\"\"\n",
    "    def __init__(self, x=0, y=0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def __str__(self, x=0, y=0):\n",
    "        return '%d %d' % (self.x, self.y)\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        add_xy = self.x+self.y + other.x+other.y\n",
    "        return add_xy\n",
    "\n",
    "\n",
    "blah = Point(5,9)\n",
    "blah2 = Point(1,10)\n",
    "\n",
    "print(blah+blah2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** Does the `distance_between_points` function you wrote in Chapter 15 work with your new and improved `Point` class? Why or why not?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`distance_between_points` from Chapter 15 should work with the new `Point` class because the new `Point` class doesn't actually change anything unless a point is printed or added to another point."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}