week01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 01\n",
    "\n",
    "Every week students are assigned readings from the course textbook:\n",
    "\n",
    "> Introduction to Programming in Python: An Interdisciplinary Approach (1st Edition)\n",
    "> Sedgewick, Robert ; Wayne, Kevin ; Dondero, Robert\n",
    "> Addison-Wesley Professional; 2015\n",
    "\n",
    "which is available online from Queen's University Libraries (https://ocul-qu.primo.exlibrisgroup.com/permalink/01OCUL_QU/sk7he5/cdi_askewsholts_vlebooks_9780134076522)\n",
    "\n",
    "The Jupyter notebooks supplement the textbook readings by highlighting important information and providing exercises that can be run directly in the notebook; also, if a student has a local copy of a notebook on their computer they can edit the notebook to add their own notes and questions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An important note about the textbook code\n",
    "\n",
    "The textbook uses a custom Python library for input and output called `stdio`. This is done so that all of the textbook code will run in both Python 2 and 3.\n",
    "\n",
    "Perhaps the most unusual feature about the textbook code is the use of `stdio.writeln` to output text to the console. For example, the `helloworld.py` program from the textbook (modified slightly to run in Jupyter) is shown in the next cell. Click in the next cell and press the *Run* button under the Jupyter menu at the top of the page to run the code in the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys  \n",
    "sys.path.insert(0, 'lib/introcs-1.0')\n",
    "\n",
    "import stdio\n",
    "\n",
    "# Write 'Hello, World' to standard output.\n",
    "stdio.writeln('Hello, World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, `stdio.writeln` can simply be replaced with the Python function `print`. Again, click in the following cell and press the *Run* button to run the code in the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write 'Hello, World' using print\n",
    "print('Hello, world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If I remove a ' then there is an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `stdio.write` is similar to `stdio.writeln` except that it does not output a newline character; this lets the programmer print several strings on the same line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys  \n",
    "sys.path.insert(0, 'lib/introcs-1.0')\n",
    "\n",
    "import stdio\n",
    "\n",
    "# Write 'Hello, World' to standard output using stdio.write to print each string separately\n",
    "stdio.write('Hello')\n",
    "stdio.write(', ')\n",
    "stdio.write('World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, `stdio.write` can simply be replaced with the Python function `print` specifying no end of line character:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write 'Hello, World' using print\n",
    "print('Hello', end='')\n",
    "print(', ', end='')\n",
    "print('World', end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.1 Executing a program*\n",
    "\n",
    "Python is often called an interpreted language which is often misinterpreted as meaning it is not a compiled language. The textbook makes it clear that this is not the case. The text making up a Python program is processed by a program called a *compiler* that translates the human readable Python code into a form (called *byte code*) that is more suitable for execution on a computer. Then, the Python interpreter directs your computer to follow these instructions. Curious students might find the [following blog post informative](https://nedbatchelder.com/blog/201803/is_python_interpreted_or_compiled_yes.html).\n",
    "\n",
    "Let's quickly revisit the \"Hello, World\" program:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write 'Hello, World' using print\n",
    "print('Hello, World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Line 1 is a Python comment. A comment is text that is ignored by Python. The comment starts at the `#` and continues to the end of the line. A comment can be placed on the same line as Python code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello, World') # a comment here is ok"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Line 2 is a Python statement that calls the Python function named `print`. A function is a named sequence of statements that performs a specific task. The `print` function prints text to what is a called a stream; when used as shown, the stream is the standard output stream (in Jupyter the output appears below the cell that was run, in Idle the output appears in the Python shell window).\n",
    "\n",
    "To *call* or *invoke* a function, write the name of the function followed by a pair of parentheses `()`.\n",
    "\n",
    "Most functions take inputs from the caller called *arguments*. The arguments appear inside of the parentheses. In the \"Hello, World\" program, the argument `'Hello, World'` is provided to the function. Text appearing inside a matched pair of single quotes or double quotes is called a *string literal*. A string is simply a sequence of characters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 1** Create a one line program that prints your name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercse 2** In the \"Hello, World\" program below remove the first `'` and run the program. Does the program run succesfully?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2\n",
    "print('Hello, World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercse 3** In the \"Hello, World\" program below remove the second `'` and run the program. Does the program run succesfully?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 3\n",
    "print('Hello, World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.1 Input and output*\n",
    "\n",
    "There is no simple way to write a Python program such as `userargument.py` in one Jupyter cell and call it from another Jupyter cell. Students should experiment with `userargument.py` using Idle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.2 Built-in types of data*\n",
    "\n",
    "The concept of a type is fundamental to programming. A data type is a set of values and a set of operations defined on those values.\n",
    "\n",
    "For example, the `int` type in Python represents the set of all integer values. Python's `int` type is somewhat unusual for programming languages in that it can represent a integer with an unlimited number of digits (well, the number of digits is limited by what can fit in computer memory). The operations that the programmer can perform with `int` values include arithmetic (addition, subtraction, multiplication, division, exponentiation) and comparison (less than, greater than equal to), and some other operations. Students interested in all of the details of the `int` type can refer to the [documentation here](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section 1.2 Definitions\n",
    "\n",
    "It's useful for new programmers to run and modify the code fragment shown in the textbook. The following cell contains a modified version of the code fragment that prints the values of the variables. Run the cell and observe the output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1234\n",
    "b = 99\n",
    "c = a + b\n",
    "print('a = ' + str(a))\n",
    "print('b = ' + str(b))\n",
    "print('c = ' + str(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The expression `str(a)` looks like a function call but is actually something called a *constructor* call. `str(a)` creates a string object corresponding to the `int` value `1234`; in other words, it creates the string `'1234'`. The reason we need to do this is because we cannot add a string object and an `int` object using the `+` operator in Python; however, we can add two string objects together using the `+` operator which joins the two strings to produce a new string. `str` is actually the name of the string type in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 4** Change the values of `a` and `b` in the program above to different integer values. Run the program and verify that you get the result that you expect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.2 Literals*\n",
    "\n",
    "The following cell contains a code fragment that illustrates the use of `float` values. Run the cell and observe the output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1.5\n",
    "y = 2.5\n",
    "z = x + y\n",
    "print('x = ' + str(x))\n",
    "print('y = ' + str(y))\n",
    "print('z = ' + str(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 5** Change the values of `x` and `y` in the program above to different float values. Run the program and verify that you get the result that you expect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 6** Change one the values of `x` and `y` in the program above to an `int` value. Run the program and verify that you get the result that you expect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell contains a code fragment that illustrates the use of `bool` values. Run the cell and observe the output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = True\n",
    "b2 = False\n",
    "b3 = b1 + b2\n",
    "print('b1 = ' + str(b1))\n",
    "print('b2 = ' + str(b2))\n",
    "print('b3 = ' + str(b3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe that Python lets you sum `bool` values. In fact, `bool` values are integer values in Python where `False` and `True` behave like the values `0` and `1`, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 7** Change the `+` operator to the `*` (multiplication) operator. Run the program and verify that you get the result that you expect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell contains a code fragment that illustrates the use of `str` values. Run the cell and observe the output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit1 = 'banana'\n",
    "fruit2 = 'mango'\n",
    "smoothie = fruit1 + fruit2\n",
    "print('fruit1 = ' + fruit1)\n",
    "print('fruit2 = ' + fruit2)\n",
    "print('smoothie = ' + smoothie)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 8** Inside the `print` function calls, change the `+` operator to a `,` and run the program. How does the output change? What happens if you add the line `print(fruit1, fruit2, smoothie)` to the end of the program and run the program?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.2 Variables*\n",
    "\n",
    "The textbook makes the unfortunate choice of using lower camelcase for its variable naming convention. For all variable names the first letter is in lower case. For multi-word variable names, the textbook capitalizes the first letter of each word after the first word; for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pizza example (textbook naming convention)\n",
    "totalSlices = 12\n",
    "cost = 17.43\n",
    "costPerSlice = cost / totalSlices\n",
    "print(costPerSlice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The standard Python code style convention ([PEP8](https://www.python.org/dev/peps/pep-0008/)) recommends the use of  the underscore to separate words in a multi-word variable name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pizza example (PEP8 naming convention)\n",
    "total_slices = 12\n",
    "cost = 17.43\n",
    "cost_per_slice = cost / total_slices\n",
    "print(cost_per_slice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the Python compiler/interpreter does not care which convention you use.\n",
    "\n",
    "It is strongly recommmended that students follow the PEP8 convention for variable naming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.2 Assignment statements*\n",
    "\n",
    "This section is very important for new programmers. An assignment statement in Python assigns a reference to a variable; the variable name always goes on the left-hand side of the `=` operator and an expression always goes on the right-hand side of the `=` operator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.2 Objects*\n",
    "\n",
    "This section is very important for new Python programmers. In Python, just about everything is an object. You can think of an object as a collection of data that has some well defined operations. For example, an `int` object has data (the digits of the integer value) and some well defined operations (addition, subtraction, etc). \n",
    "\n",
    "The textbook says that an object has three characteristics:\n",
    "\n",
    "1. *identity*: a piece of information that uniquely identifies the object\n",
    "2. *type*: the set of values represented by the object and the operations that can be performed with the object\n",
    "3. *value*: the actual value that the object represents\n",
    "\n",
    "You can imagine computer memory as being a series of boxes numbered 0, 1, 2, ... The box number is the *address* of the box. Each box has a fixed size and can hold at most one object. This is why the textbook says that the memory address is identity of an object; if you know the memory address of an object you can always find the object. Of course, this is a very simplistic model of computer memory, but it suffices for the time being."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.2 Object references*\n",
    "\n",
    "In Python, a variable always stores the identity of an object (remember the identity is just the memory address of the object). We say that Python variables store *object references* because the variable *refers* to an object (the variable is not the actual object).\n",
    "\n",
    "In the following code fragment:\n",
    "\n",
    "```python\n",
    "a = 1234\n",
    "```\n",
    "\n",
    "the variable `a` is not the value `1234`; the variable `a` refers to an `int` object whose value is `1234`.\n",
    "\n",
    "If this confuses you consider the following analogy. Suppose that your best friend has the name Maya. The name Maya is not your best friend; the name Maya refers to the person that is your best friend.\n",
    "\n",
    "To extend the analogy, suppose that you have the nickname MyMy for your friend Maya. The name MyMy is not your best friend; the name MyMy refers to the person that is your best friend. Notice that you have two different names *that both refer to your best friend*. We say that Maya and MyMy are *aliases*.\n",
    "\n",
    "In Python, you create an alias by assigning a variable to another existing variable. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1234\n",
    "b = a\n",
    "print(a)\n",
    "print(b)\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, `a` and `b` both refer to the same `int` object whose value is `1234`. The operator `is` compares the identity of two objects; it returns `True` if the two variables refer to the same object.\n",
    "\n",
    "The fact that `a` and `b` refer to the same `int` object does not have any important consequences because the type `int` is an *immutable* type. This means that the value of an `int` object is unchangeable; if you want a different value you need to create a new `int` object to represent that value.\n",
    "\n",
    "Aliasing becomes much more important when we study *mutable* types (probably in Week 3)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 9** There is only one `int` object in the example above. Change the line `b = a` to `b = 1234` and run the program. Based on the output of the program, how many `int` objects are there in the modified version of the program?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.2 Example: exchanging two variables*\n",
    "\n",
    "Every new programmer eventually sees a variation of the following problem:\n",
    "\n",
    "Suppose that you have two variables `x` and `y` defined as:\n",
    "\n",
    "```python\n",
    "x = 1000\n",
    "y = 2000\n",
    "```\n",
    "\n",
    "Show how to swap the values of variables `x` and `y` so that `x` refers to the object that `y` currently refers to and `y` refers to the object that `x` currently refers to.\n",
    "\n",
    "At least one student will write:\n",
    "\n",
    "```python\n",
    "x = 1000\n",
    "y = 2000\n",
    "\n",
    "x = 2000\n",
    "y = 1000\n",
    "```\n",
    "\n",
    "which is incorrect as the following shows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1000\n",
    "y = 2000\n",
    "x = 2000\n",
    "print(x is y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is true is that `x` and `y` both refer to objects whose values are `2000` but they refer to different objects.\n",
    "\n",
    "Some students will write:\n",
    "\n",
    "```python\n",
    "x = 1000\n",
    "y = 2000\n",
    "\n",
    "x = y\n",
    "y = x\n",
    "```\n",
    "\n",
    "which is incorrect as the following shows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1000\n",
    "y = 2000\n",
    "\n",
    "x = y    # ok, x refers to the int object 2000\n",
    "y = x    # oops, y refers to the same object as x which we just changed on the previous line\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The line `x = y` means `x` refers to the same object that `y` currently refers to (the `int` object `2000`). The next line `y = x` means `y` refers to the same object that `x` currently refers to, but the previous line made `x` refer to the `int` object `2000`.\n",
    "\n",
    "The correct way to swap two values is to introduce a third temporary variable to remember one of the two values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1000\n",
    "y = 2000\n",
    "\n",
    "tmp = x  # remember the current value of x\n",
    "x = y    # ok, x refers to the int object 2000\n",
    "y = tmp  # ok, y refers to the int object 1000\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.2 Strings*\n",
    "\n",
    "The `ruler.py` example is confusing if you have never used an Imperial ruler where the units are inches. The take home message from this example is that it is easy to create a program that produces an exponential amount of output. Every additional line that you add to the calculation (approximately) doubles the amount of output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.2 Integers*\n",
    "\n",
    "You might be wondering why the ordinary division operator `/` is missing from this section. The reason is because the meaning of `/` changed between Python 2 and Python 3. In Python 3, `/` will always produce a floating-point value (an approximation of a real non-integer number). A version of `intops.py` that includes the `+` (positive), `-` (negative), and `/` (division) operators is shown in the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1234\n",
    "b = 5\n",
    "\n",
    "pos = +a\n",
    "neg = -a\n",
    "total = a + b\n",
    "diff = a - b\n",
    "prod = a * b\n",
    "div = a / b\n",
    "floor_div = a // b\n",
    "rem = a % b\n",
    "exp = a ** b\n",
    "\n",
    "print('+' + str(a) + ' = ' + str(pos))\n",
    "print('-' + str(a) + ' = ' + str(neg))\n",
    "print(str(a) + ' +  ' + str(b) + ' = ' + str(total))\n",
    "print(str(a) + ' -  ' + str(b) + ' = ' + str(diff))\n",
    "print(str(a) + ' *  ' + str(b) + ' = ' + str(prod))\n",
    "print(str(a) + ' /  ' + str(b) + ' = ' + str(div))\n",
    "print(str(a) + ' // ' + str(b) + ' = ' + str(floor_div))\n",
    "print(str(a) + ' %  ' + str(b) + ' = ' + str(rem))\n",
    "print(str(a) + ' ** ' + str(b) + ' = ' + str(exp))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The remainder operator `%` computes the remainder after integer division. For example `17 % 3` is equal to `2` because 17 divided by 3 is equal to 5 with a remainder of 2.\n",
    "\n",
    "The remainder operator is commonly used in the following computations:\n",
    "\n",
    "* determine if an integer is even or odd\n",
    "* determine if an integer is divisible by a certain value\n",
    "* to perform some task every $n$th time\n",
    "* working with cyclic quantities such as degrees on a circle, hours and minutes on a clock, and number of cents in a North American amount of money\n",
    "\n",
    "The first three items in the list above require comparison operators or loops which are topics we will visit next week.\n",
    "\n",
    "Cyclic quantities are quantities that are restricted to a range of values; exceeding the maximum value of the range causes the value to wrap around towards the minimum value and exceeding the minimum value of the range causes the value to wrap around towards the maximum value. For example, the angle of a point on a circle is a value between 0 degrees (inclusive) and 360 degrees (exclusive). Going around the circle more than once causes the angle to wrap; for example 361 degrees wraps around to 1 degree. Wrapping a value is performed using the remainder operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "deg = 361\n",
    "wrapped = deg % 360\n",
    "print(str(deg) + ' degrees wraps to : ' + str(wrapped) + ' degrees');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reader should change `deg` to a negative value and confirm that the output matches the expected result. The reader should also try values equal to -360 and 360 degrees."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A currency example that uses both floored division and remainder is computing the number of dollars and cents equal to a given number of cents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_cents = 208\n",
    "dollars = total_cents // 100\n",
    "cents = total_cents % 100\n",
    "print(str(total_cents) + ' cents is equal to ' + str(dollars) + ' dollars and ' + str(cents) + ' cents');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 10** Compute and print the value of the following continued fraction; do not simplify any of parts of the fraction (you should get the value 8.5):\n",
    "\n",
    "$$8 + \\cfrac{1}{3\n",
    "          + \\cfrac{1}{-2\n",
    "          + \\cfrac{1}{0.5 + \\cfrac{1}{2} } } }$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 11** Suppose that there are 315 students in a class. For a class pizza party, the teacher orders sixty 16-slice pizzas. How many students can receive 4 slices of pizza if all of the remaining students receive 3 slices? Solve the problem in the following cell using the `%` operator as part of your solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 12** One way to represent the time of day is as the number of seconds after midnight. For example, 0 seconds after midnight is midnight and 86399 seconds after midnight is 23:59:59 (1 second to midnight). Calculate the integer number of hours, minutes, and seconds that are equivalent to a given number of seconds after midnight. For example, 86399 seconds after midnight is equal to 23 hours, 59 minutes, and 59 seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 13** If you pay for an item using cash in Canada then the price is always rounded down to the nearest nickel. Given the original price of an item in cents compute the cash price of the item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Textbook section *1.1 Floating-point numbers*\n",
    "\n",
    "Floored division also works with floating-point numbers. The result of floored division is always a whole number but the result does not necessarily have the type `int`. Also, the results can be confusing if the operands are not whole numbers.\n",
    "\n",
    "Similarly, the remainder operator is also defined for floating-point numbers but the result can be confusing if the operands are not whole numbers. \n",
    "\n",
    "A version of `floatops.py` that includes the `+` (positive), `-` (negative), `//` (floored division), and `%` (remainder) operators is shown in the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3.5\n",
    "b = 0.1\n",
    "\n",
    "pos = +a\n",
    "neg = -a\n",
    "total = a + b\n",
    "diff = a - b\n",
    "prod = a * b\n",
    "div = a / b\n",
    "floor_div = a // b\n",
    "rem = a % b\n",
    "exp = a ** b\n",
    "\n",
    "print('+' + str(a) + ' = ' + str(pos))\n",
    "print('-' + str(a) + ' = ' + str(neg))\n",
    "print(str(a) + ' +  ' + str(b) + ' = ' + str(total))\n",
    "print(str(a) + ' -  ' + str(b) + ' = ' + str(diff))\n",
    "print(str(a) + ' *  ' + str(b) + ' = ' + str(prod))\n",
    "print(str(a) + ' /  ' + str(b) + ' = ' + str(div))\n",
    "print(str(a) + ' // ' + str(b) + ' = ' + str(floor_div))\n",
    "print(str(a) + ' %  ' + str(b) + ' = ' + str(rem))\n",
    "print(str(a) + ' ** ' + str(b) + ' = ' + str(exp))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that `3.5 // 0.1` is not equal to `35.0`; instead it is equal to `34.0`. The reason this happens is because of the imprecision inherent in floating-point arithmetic. Most computers cannot represent the real value 0.1 exactly using the standard floating-point representation. The floating-point value of 0.1 is (very slightly) greater than 0.1 so when you ask Python to perform floor division you get the result `34.0` instead of `35.0`.\n",
    "\n",
    "The result of `3.5 % 0.1` is even more confusing than the result for floored division. The mathematically inclined can refer to the [documentation of binary arithmetic operations](https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations) for an explanation.\n",
    "\n",
    "After seeing these results, you can probably understand why the authors chose to leave these operators from this section!"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}