03 List comprehensions errors conditional statements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_cell": true
   },
   "source": [
    "<span class='note'><i>Make me look good.</i> Click on the cell below and press <kbd>Ctrl</kbd>+<kbd>Enter</kbd>.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hide_cell": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Lora:400,700,400i,700i' rel='stylesheet'>\n",
       "<link href='https://fonts.googleapis.com/css?family=Lato:300,400,700,300i,400i,700i' rel='stylesheet'>\n",
       "<link href='https://fonts.googleapis.com/css?family=Inconsolata:400' rel='stylesheet'>\n",
       "<link rel=\"stylesheet\" href=\"http://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css\">\n",
       "<style>\n",
       "    h1, h2, h3, h4, h5 {\n",
       "        font-family: 'Lato', sans-serif;\n",
       "    }\n",
       "    h5 {\n",
       "        font-style: normal;\n",
       "    }\n",
       "    kbd {\n",
       "        font-family: Lato, serif;\n",
       "    }\n",
       "    hr {\n",
       "      border-width: 2px;\n",
       "      border-color: #a9a9a9;\n",
       "    }\n",
       "    .cite {\n",
       "        font-size: 85%;\n",
       "        text-align: right;\n",
       "        margin-top: 10px;\n",
       "    }\n",
       "    .note {\n",
       "        font-family: Lora, serif;\n",
       "        font-size: 10pt;\n",
       "        font-weight: 400;\n",
       "        margin-top: 0;\n",
       "        margin-bottom: 0;\n",
       "    }\n",
       "    h5.prehead {\n",
       "        font-family: Lato, serif;\n",
       "        font-style: normal;\n",
       "        font-size: 13pt;\n",
       "        font-weight: 300;\n",
       "        margin-bottom: 15px;\n",
       "        margin-top: 30px;\n",
       "    }\n",
       "    h5.lesson {\n",
       "        font-family: Lato, serif;\n",
       "        font-weight: 400;\n",
       "        font-size: 15pt;\n",
       "        font-style: normal;\n",
       "        margin-top: 0px;\n",
       "        margin-bottom: 5px;\n",
       "    }\n",
       "    h1.lesson_title {\n",
       "        font-family: Lato, serif;\n",
       "        font-weight: 300;\n",
       "        font-size: 32pt;\n",
       "        line-height: 110%;\n",
       "        color:#CD2305;\n",
       "        margin-top: 0px;\n",
       "        margin-bottom: 15px;\n",
       "    }\n",
       "    div.cell{\n",
       "        max-width: 960px;\n",
       "        margin-left: auto;\n",
       "        margin-right: auto;\n",
       "    }\n",
       "    div.text_cell_render {\n",
       "        font-family: Lora, serif;\n",
       "        line-height: 160%;\n",
       "        font-size: 11pt;\n",
       "    }\n",
       "    .rendered_html pre, .rendered_html code  {\n",
       "        font-family: Inconsolata, monospace !important;\n",
       "        font-size: 11pt;\n",
       "    }\n",
       "    div.CodeMirror, div.output_area pre, div.prompt {\n",
       "        font-family: Inconsolata, monospace !important;\n",
       "        font-size: 110%;\n",
       "    }\n",
       "    .rendered_html ul li {\n",
       "        margin-top: 0.75em;\n",
       "        margin-bottom: 0.75em;\n",
       "    }\n",
       "    .rendered_html ul li ul li {\n",
       "        margin-top: 0.5em;\n",
       "        margin-bottom: 0.5em;\n",
       "    }\n",
       "    .rred {\n",
       "        color: #a00000;\n",
       "    }\n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": \"0.75em 0\"}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "HTML(open('css/custom.css', 'r').read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hide_cell": true
   },
   "source": [
    "<h5 class='prehead'>SM286D &middot; Introduction to Applied Mathematics with Python &middot; Spring 2020 &middot; Uhan</h5>\n",
    "\n",
    "<h5 class='lesson'>Lesson 3.</h5>\n",
    "\n",
    "<h1 class='lesson_title'>List comprehensions, errors, conditional statements</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## This lesson..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- List comprehensions\n",
    "\n",
    "- Errors\n",
    "     - Syntax errors\n",
    "     - Logical errors\n",
    "     \n",
    "- Conditional tests and statements\n",
    " \n",
    "- Advanced Jupyter features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Warm up.__ Use a `for` loop and the `.append()` method to create a list of the first 10 cubic numbers, starting with $0^3, 1^3, 2^3, ...$ Print the list to check your work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "# Initialize empty list\n",
    "cubics = []\n",
    "\n",
    "# Iterate over first 10 integers, starting at 0\n",
    "for i in range(10):\n",
    "    cubics.append(i**3)\n",
    "\n",
    "# Print the list\n",
    "print(cubics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A __list comprehension__ is a compact way of constructing lists.\n",
    "\n",
    "- For example, to create the same list we built in the above warm up example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]\n"
     ]
    }
   ],
   "source": [
    "# Create list with list comprehension\n",
    "another_cubics = [i**3 for i in range(10)]\n",
    "\n",
    "# Print the list\n",
    "print(another_cubics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To write a list comprehension:\n",
    "    - Open a set of square brackets.\n",
    "    - Write the expression for the values you want to store in the list.\n",
    "    - Then, write a for loop to generate the numbers you want to feed into the expression.\n",
    "    - Close the square brackets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- List comprehensions are 😎 (and easier to read and write when you get used to them)...\n",
    "\n",
    "- But the `.append()` technique is 👍 too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python is a language in much the same way that English is a language.\n",
    "    - When we construct a sentence in English, we must follow the \"rules\" of English.  These \"rules\" are called grammar.\n",
    "    - When we write code in Python, we must follow the \"rules\" of Python.  These \"rules\" are called __syntax__.\n",
    "\n",
    "- Below is an example of a poorly constructed, grammatically incorrect, English sentence.\n",
    "\n",
    "    > The dawg the car chsed exited.\n",
    "\n",
    "- Note that our brains can sometimes make sense of even very poorly constructed sentences in English.  \n",
    "\n",
    "- The Python interpreter is not as forgiving.\n",
    "\n",
    "- Let's look at an example of Python code that contains syntax errors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-4-715aeb7e83f0>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-4-715aeb7e83f0>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    For i in RANGE(1, 11)\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Print the numbers 1 through 10\n",
    "For i in RANGE(1, 11)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Let's fix this code together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the numbers 1 through 10\n",
    "For i in RANGE(1, 11)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What was wrong?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Write your notes here. Double-click to edit._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Sometimes Python's error messages are misleading. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-5-05c6a87bb9e0>, line 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-5-05c6a87bb9e0>\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m    veggies.sort()\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Define list of veggies\n",
    "veggies = ['lettuce', 'celery', 'carrot', 'cucumber'\n",
    "\n",
    "# Sort veggies in alphabetical order\n",
    "veggies.sort()\n",
    "\n",
    "# Print the list of veggies in alphabetical order\n",
    "print(veggies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- __Important tip.__ Always check <span style=\"rred\">above</span> the code that Python points you to in an error message, just in case.\n",
    "\n",
    "- Let's fix this code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define list of veggies\n",
    "veggies = ['lettuce', 'celery', 'carrot', 'cucumber'\n",
    "\n",
    "# Sort veggies in alphabetical order\n",
    "veggies.sort()\n",
    "\n",
    "# Print the list of veggies in alphabetical order\n",
    "print(veggies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What was wrong?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Write your notes here. Double-click to edit._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical Errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- When we write English sentences, we might introduce logical errors that lead to unintended meanings.  For example:\n",
    "\n",
    "    > Let's eat, Grandma!\n",
    "    > \n",
    "    > Let's eat Grandma!\n",
    "\n",
    "- We can also introduce logical errors when writing Python code. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "# Create a list containing all odd numbers from 1 - 20\n",
    "odd_numbers = []\n",
    "for number in range(0, 20, 2):\n",
    "    print(number)\n",
    "\n",
    "# Let's check our work\n",
    "print(odd_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Note that when we ran the code, we didn't get any error messages. However, we didn't get we what wanted.\n",
    "\n",
    "- Let's fix this code together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list containing all odd numbers from 1 - 20\n",
    "odd_numbers = []\n",
    "for number in range(0, 20, 2):\n",
    "    print(number)\n",
    "\n",
    "# Let's check our work\n",
    "print(odd_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- General tips to avoid logical errors (and 🤬):\n",
    "    - Write your code piece-by-piece. Start with the smaller, easier parts first, and build on that.\n",
    "    - Check your work often by running your code, even if it isn't complely finished."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A __conditional test__ is an expression that evaluates to `True` or `False`.\n",
    "\n",
    "- Perhaps the most basic conditional test is to __check for equality__ using the `==` operator:\n",
    "    - If the two items on either side of `==` are equal, then it returns `True`.\n",
    "    - Otherwise, it returns `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's define today to be Tuesday\n",
    "today = \"Tuesday\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Is today Tuesday?\n",
    "print(today == 'Tuesday')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# Is today Friday?\n",
    "print(today == 'Friday')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Other types of comparisons:\n",
    "\n",
    "| Comparison | Meaning |\n",
    "| :----------- | :-------- |\n",
    "| `==`         | equal  |\n",
    "| `!=`         | not equal |\n",
    "| `<`          | less than  |\n",
    "| `>`          | greater than |\n",
    "| `<=`         | less than or equal |\n",
    "| `>=`         | greater than or equal |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **WARNING!** In Python:\n",
    "    - A <span class=\"rred\">single</span> equal sign `=` is used to assign the value of something.\n",
    "    - A <span class=\"rred\">double</span> equal sign `==` is used to check if something is equal to something else."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can combine multiple conditional tests using `and` and `or`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Let's define a variable with our age\n",
    "age = 85\n",
    "\n",
    "# Am I between 20 and 30 years old?\n",
    "print((age >= 20) and (age <= 30))\n",
    "\n",
    "# Am I under 20 or over 30 years old?\n",
    "print((age < 20) or (age > 30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also check if a value is in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Define list of veggies again\n",
    "veggies = ['lettuce', 'celery', 'carrot', 'cucumber']\n",
    "\n",
    "# Is 'cucumber' in our list of veggies?\n",
    "print('cucumber' in veggies)\n",
    "\n",
    "# ... but is 'Cucumber' in our list of veggies?\n",
    "print('Cucumber' in veggies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Simple `if` statements:\n",
    "    \n",
    "    ```\n",
    "    if conditional_test:\n",
    "        do something\n",
    "    ```\n",
    "\n",
    "- For example, to check if a number is a mutliple of 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 15 is a multiple of 3.\n"
     ]
    }
   ],
   "source": [
    "# Pick a number\n",
    "number = 15\n",
    "\n",
    "# Check if it is a multiple of 3\n",
    "if number % 3 == 0:\n",
    "    print(f'The number {number} is a multiple of 3.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `if`-`else` statements:\n",
    "\n",
    "    ```\n",
    "    if conditional_test:\n",
    "        do something\n",
    "    else:\n",
    "        conditional_test is False, so do something else\n",
    "    ```\n",
    "- Building upon the previous example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 14 is NOT a multiple of 3.\n"
     ]
    }
   ],
   "source": [
    "# Pick a number\n",
    "number = 14\n",
    "\n",
    "# Check if it is a multiple of 3\n",
    "if number % 3 == 0:\n",
    "    print(f'The number {number} is a multiple of 3.')\n",
    "else:\n",
    "    print(f'The number {number} is NOT a multiple of 3.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `if`-`elif`-`else` statements:\n",
    "    \n",
    "    ```\n",
    "    if conditional_test_1:\n",
    "        do something\n",
    "    elif conditional_test_2:\n",
    "        here, conditional_test_1 is False, but conditional_test_2 is True\n",
    "        do something else\n",
    "    else:\n",
    "        here, both conditional_test_1 and conditional_test_2 are False\n",
    "        do something craaaazy\n",
    "   ```\n",
    "- The `else` part is optional (i.e. you can have an `if`-`elif` statement).\n",
    "\n",
    "- What's the difference between using an `if`-`elif` statement vs. two `if` statements? Let's take a look at the following two examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"800\"\n",
       "            height=\"450\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=%23%20Pick%20a%20number%0Anumber%20%3D%2015%0A%0A%23%20Check%20if%20it%20is%20a%20multiple%20of%203%0Aif%20number%20%25%203%20%3D%3D%200%3A%0A%20%20%20%20print%28f'The%20number%20%7Bnumber%7D%20is%20a%20multiple%20of%203.'%29%0Aelif%20number%20%25%205%20%3D%3D%200%3A%0A%20%20%20%20print%28f'The%20number%20%7Bnumber%7D%20is%20a%20multiple%20of%205.'%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1083f9208>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(\"http://pythontutor.com/iframe-embed.html#code=%23%20Pick%20a%20number%0Anumber%20%3D%2015%0A%0A%23%20Check%20if%20it%20is%20a%20multiple%20of%203%0Aif%20number%20%25%203%20%3D%3D%200%3A%0A%20%20%20%20print%28f'The%20number%20%7Bnumber%7D%20is%20a%20multiple%20of%203.'%29%0Aelif%20number%20%25%205%20%3D%3D%200%3A%0A%20%20%20%20print%28f'The%20number%20%7Bnumber%7D%20is%20a%20multiple%20of%205.'%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\", width=800, height=450)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"800\"\n",
       "            height=\"450\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=%23%20Pick%20a%20number%0Anumber%20%3D%2015%0A%0A%23%20Check%20if%20it%20is%20a%20multiple%20of%203%0Aif%20number%20%25%203%20%3D%3D%200%3A%0A%20%20%20%20print%28f'The%20number%20%7Bnumber%7D%20is%20a%20multiple%20of%203.'%29%0Aif%20number%20%25%205%20%3D%3D%200%3A%0A%20%20%20%20print%28f'The%20number%20%7Bnumber%7D%20is%20a%20multiple%20of%205.'%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1083f9278>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame(\"http://pythontutor.com/iframe-embed.html#code=%23%20Pick%20a%20number%0Anumber%20%3D%2015%0A%0A%23%20Check%20if%20it%20is%20a%20multiple%20of%203%0Aif%20number%20%25%203%20%3D%3D%200%3A%0A%20%20%20%20print%28f'The%20number%20%7Bnumber%7D%20is%20a%20multiple%20of%203.'%29%0Aif%20number%20%25%205%20%3D%3D%200%3A%0A%20%20%20%20print%28f'The%20number%20%7Bnumber%7D%20is%20a%20multiple%20of%205.'%29&codeDivHeight=400&codeDivWidth=350&cumulative=false&curInstr=0&heapPrimitives=nevernest&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\", width=800, height=450)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced Jupyter features that might be useful"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyboard shortcuts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* There are keyboard shortcuts, but they can be a little tricky to use. Take a look at __Help &#8594; Keyboard Shortcuts__.\n",
    "\n",
    "* If you click in the text box of a code cell or double-click in a Markdown cell, then it is outlined by a green box. This is called __Edit Mode__.\n",
    "\n",
    "* If you click on the <span class=\"rred\">side</span> of a code cell, then it is outlined by a blue box. This is called __Command Mode__.\n",
    "\n",
    "* To enter Command Mode from Edit mode, press <kbd>Esc</kbd>.\n",
    "\n",
    "* Here are three really useful keyboard shortcuts:\n",
    "    * __Indenting multiple lines.__ In Edit Mode, highlight the lines you want to indent, and then press <kbd>Tab</kbd>. If you want to de-indent them (i.e. indent them to the left), press <kbd>Shift</kbd>+<kbd>Tab</kbd>.\n",
    "    * __Commenting multiple lines.__ In Edit Mode, highlight the lines you want to comment, and then press <kbd>Ctrl</kbd>+<kbd>/</kbd>. Press <kbd>Ctrl</kbd>+<kbd>/</kbd> again to uncomment those lines.\n",
    "    * __Line numbers.__ In Command Mode, press <kbd>L</kbd> to show/hide line numbers in the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name of this student is Amy.\n",
      "The name of this student is all uppercase is AMY.\n",
      "The name of this student is all lowercase is amy.\n",
      "The name of this student is Bob.\n",
      "The name of this student is all uppercase is BOB.\n",
      "The name of this student is all lowercase is bob.\n",
      "The name of this student is Carol.\n",
      "The name of this student is all uppercase is CAROL.\n",
      "The name of this student is all lowercase is carol.\n"
     ]
    }
   ],
   "source": [
    "# Try turning on and turning off line numbers in this cell.\n",
    "# Play around with indenting and de-indenting code.\n",
    "student_names = [\"Amy\", \"Bob\", \"Carol\"]\n",
    "for name in student_names:\n",
    "    print(f\"The name of this student is {name}.\")\n",
    "    print(f\"The name of this student is all uppercase is {name.upper()}.\")\n",
    "    print(f\"The name of this student is all lowercase is {name.lower()}.\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running multiple cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* You can run all the cells in a notebook by selecting __Cell &#8594; Run All__.\n",
    "\n",
    "* You can run all the cells above/below the current cell by selecting __Cell &#8594; Run All Above/Below__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clearing the output of code cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* You can clear the output of a code cell by selecting __Cell &#8594; Current Output &#8594; Clear__. \n",
    "\n",
    "* You can clear the output of all code cells by selecting __Cell &#8594; All Output &#8594; Clear__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classwork &mdash; on your own!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 1.__  In this question we work with numbers mod 7. The number 8 is equal to (1 mod 7) because its remainder upon division by 7 is equal to 1. You can compute and print the value of (8 mod 7) in Python by writing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(8 % 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using a `for` loop and an `if` statement, compute the sum of the positive integers less than 55 that are equal to (1 mod 7)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of the numbers from 1 to 55 that equal 1 mod 7 is 204.\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "# Initialize total value to 0\n",
    "total = 0 \n",
    "\n",
    "# Iterate over all positive integers less than 55\n",
    "for i in range(1, 56):\n",
    "    \n",
    "    # Check if the integer is equal to 1 mod 7\n",
    "    # If so, include it in the total\n",
    "    if i % 7 == 1: \n",
    "        total += i\n",
    "        \n",
    "print(f\"The sum of the numbers from 1 to 55 that equal 1 mod 7 is {total}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 2.__ (PCC 5-10: Checking Usernames) Do the following to create a program that simulates how websites ensure that everyone has a unique username. \n",
    "\n",
    " - Make a list of five or more usernames called `current_users`.\n",
    " - Make another list of five usernames called `new_users`. Make sure one or two of the new usernames are also in the `current_users` list.\n",
    " - Loop through the `new_users` list to see if each new username has already been used. If it has, print a message that the person will need to enter a new username. If a username has not been used, print a message saying that the username is available.\n",
    " - Make sure your comparison is case insensitive. For example, if 'John' has been used, 'JOHN' should not be accepted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm sorry, the username 'JOHN' is unavailable.\n",
      "Congratulations! The user name 'Edith' is available'!\n",
      "Congratulations! The user name 'Kevin' is available'!\n",
      "Congratulations! The user name 'Jody' is available'!\n",
      "I'm sorry, the username 'cindy' is unavailable.\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "# List of current usernames\n",
    "current_users = ['John', 'Emily', 'Carl', 'Jake', \"Cindy\"]\n",
    "\n",
    "# List of new usernames\n",
    "new_users = ['JOHN', 'Edith', \"Kevin\", \"Jody\", \"cindy\"]\n",
    "\n",
    "# To make comparisons case insensitive, let's make a new list\n",
    "# with the current usernames in lowercase\n",
    "current_users_lower = []\n",
    "for name in current_users:\n",
    "    current_users_lower.append(name.lower())\n",
    "\n",
    "# Iterate over new user names\n",
    "for name in new_users:\n",
    "    # Check if the name (in all lowercase) is in \n",
    "    # the list of current users (in all lowercase)\n",
    "    if name.lower() in current_users_lower: \n",
    "        print(f\"I'm sorry, the username '{name}' is unavailable.\")\n",
    "    else:\n",
    "        print(f\"Congratulations! The user name '{name}' is available'!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 3.__ (PCC 5-11: Ordinal Numbers) Ordinal numbers indicate their position in a list, such as 1st or 2nd. Most ordinal numbers end in th, except 1, 2, and 3.\n",
    "\n",
    " - Store the numbers 1 through 9 in a list.\n",
    " - Loop through the list.\n",
    " - Use an `if`-`elif`-`else` chain inside the loop to print the proper ordinal ending for each number. Your output should look like this:\n",
    "     ```\n",
    "     1st\n",
    "     2nd\n",
    "     3rd\n",
    "     4th\n",
    "     5th\n",
    "     6th\n",
    "     7th\n",
    "     8th\n",
    "     9th\n",
    "     ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1st\n",
      "2nd\n",
      "3rd\n",
      "4th\n",
      "5th\n",
      "6th\n",
      "7th\n",
      "8th\n",
      "9th\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "# List of numbers 1 through 9\n",
    "numbers = list(range(1,10))\n",
    "\n",
    "# Iterate through the numbers\n",
    "# Check for special cases of ordinal endings\n",
    "for number in numbers: \n",
    "    if number == 1: \n",
    "        print(\"1st\")\n",
    "    elif number == 2: \n",
    "        print(\"2nd\")\n",
    "    elif number == 3:\n",
    "        print(\"3rd\")\n",
    "    else: \n",
    "        print(f\"{number}th\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 4.__ (PCC 5-13: Your Ideas) At this point, you are a more capable programmer than you were when you started this book. Now that you have a better sense of how real-world situations are modeled in programs, you might be thinking of some problems you could solve with your own programs. Record any new ideas you have about problems you might want to solve as your programming skills continue to improve. Consider games you might want to write, data sets you might want to explore, and web applications you would like to create."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Write your ideas here. Double-click to edit._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 5.__  In the code cell below, we have the data for several recipes from Cooking Light Magazine, September 2016:\n",
    "\n",
    " - Kale, Mushroom, and Bacon Pita Pizzas\n",
    " - Pea, Tomato and Bacon Gnochi\n",
    " - Kale and Mushroom Quinoa with Romanesco\n",
    " - Kale, Apple and Almond Chicken Salad\n",
    " - Kale Pesto Pasta with Shrimp\n",
    " - Stacked Chicken Enchiladas\n",
    "\n",
    "<img width=200 src=\"img/cooking.jpg\">\n",
    "\n",
    "Use the variables defined below for your code. We store the six names in the above order in the list `recipe_names`. Corresponding data is stored in the lists `recipe_active_times`, `recipe_total_times`, `recipe_calories`, `recipe_fats`, `recipe_proteins`, `recipe_carbs`, `recipe_fibers`, `recipe_sugars`, `recipe_cholesterols`, `recipe_irons`, `recipe_sodiums`, `recipe_calciums`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Recipe data - do not modify\n",
    "recipe_names = ['pizza', 'gnochi', 'quinoa', 'chicken salad', \n",
    "                'pasta with shrimp', 'enchiladas']\n",
    "recipe_active_times = [30, 18, 25, 35, 20, 25]\n",
    "recipe_total_times = [30, 30, 40, 35, 20, 40]\n",
    "recipe_calories = [314, 301, 519, 318, 472, 348]\n",
    "recipe_fats = [11.9, 8.7, 25.1, 20.6, 21.7, 14.5]\n",
    "recipe_proteins = [13, 10, 22, 20, 24, 29]\n",
    "recipe_carbs = [41, 44, 53, 14, 46, 28]\n",
    "recipe_fibers = [9, 10, 7, 4, 8, 5]\n",
    "recipe_sugars = [5, 3, 6, 6, 1, 3]\n",
    "recipe_cholesterols = [10, 13, 186, 81, 114, 101]\n",
    "recipe_irons = [3, 5, 5, 2, 3, 1]\n",
    "recipe_sodiums = [492, 640, 722, 447, 575, 613]\n",
    "recipe_calciums = [139, 68, 169, 159, 241, 329]    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Print the names of the recipes that can be cooked in less than or equal\tto half an hour. Use a `for` loop to do so without hard coding the number of recipes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pizza takes no more than half an hour to cook.\n",
      "Gnochi takes no more than half an hour to cook.\n",
      "Pasta With Shrimp takes no more than half an hour to cook.\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "for i in range(len(recipe_names)):\n",
    "    if recipe_total_times[i] <= 30:\n",
    "        print(f\"{recipe_names[i].title()} takes no more than half an hour to cook.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.  Print the names of the recipes that have less than 400 calories and more than 5g of fiber. Use a `for` loop to do so without hard coding the number of recipes.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pizza has less than 400 calories and more than 5g of fiber.\n",
      "Gnochi has less than 400 calories and more than 5g of fiber.\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "for i in range(len(recipe_names)):\n",
    "    if recipe_calories[i] < 400 and recipe_fibers[i] > 5:\n",
    "        print(f\"{recipe_names[i].title()} has less than 400 calories and more than 5g of fiber.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.  Print the names of the recipes that have more than 20g of protein or less than 3g of sugar.  Use a loop to do so without hard coding the number of recipes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quinoa has more than 20g of protein or less than 3g of sugar.\n",
      "Pasta With Shrimp has more than 20g of protein or less than 3g of sugar.\n",
      "Enchiladas has more than 20g of protein or less than 3g of sugar.\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "for i in range(len(recipe_names)):\n",
    "    if recipe_proteins[i] > 20 or recipe_sugars[i] < 3:\n",
    "        print(f\"{recipe_names[i].title()} has more than 20g of protein or less than 3g of sugar.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 6.__ (Seven Up) Seven Up is a fun game to play with elementary school students. Going around the room, each student says a number in the sequence 1, 2, 3,... However, if a number ends in seven (like 17) or if a number is divisible by 7 (like 14) then the student instead says \"up\". In the game, when a student makes a mistake, they are eliminated and the remainder of the class starts again at 1, but we'll assume that our students always say the correct thing. \n",
    "\n",
    "1. The class counts to 50. Make a list consisting of strings containing the things that the students say. Your list should start with \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", and \"up\". Print the list to check your work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 'up', 8, 9, 10, 11, 12, 13, 'up', 15, 16, 'up', 18, 19, 20, 'up', 22, 23, 24, 25, 26, 'up', 'up', 29, 30, 31, 32, 33, 34, 'up', 36, 'up', 38, 39, 40, 41, 'up', 43, 44, 45, 46, 'up', 48, 'up', 50]\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "# Initialize empty list of the things that the students say\n",
    "students_say = []\n",
    "\n",
    "# Iterate through numbers 1 to 50\n",
    "for i in range(1, 51):\n",
    "    # If the number is divisible by 7 \n",
    "    # or if the number ends in 7, \n",
    "    # add \"up\" to the list\n",
    "    if (i % 7 == 0) or ((i - 7) % 10 == 0):\n",
    "        students_say.append(\"up\")\n",
    "    # Otherwise, add the number to the list\n",
    "    else:\n",
    "        students_say.append(i)\n",
    "\n",
    "# Print the list\n",
    "print(students_say)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. If there are 18 students in the class and they count until 1000, make a list containing the things that are said by the 3rd student. The 3rd student starts with \"3\" and then \"up\". Print the list to check your work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 'up', 39, 'up', 75, 93, 111, 129, 'up', 165, 183, 201, 219, 'up', 255, 'up', 291, 309, 'up', 345, 363, 381, 'up', 'up', 435, 453, 471, 489, 'up', 'up', 543, 561, 579, 'up', 615, 633, 'up', 669, 'up', 705, 723, 741, 759, 'up', 795, 813, 831, 849, 'up', 885, 'up', 921, 939, 'up', 975, 993]\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "# Initialize empty list of the things that the 3rd student says\n",
    "third_student_says = []\n",
    "\n",
    "# Iterate through the integers 1 to 1000\n",
    "for i in range(1, 1000):\n",
    "    # Check if the 3rd student is supposed to say something\n",
    "    if i % 18 == 3:\n",
    "        # If the number is divisible by 7 \n",
    "        # or if the number ends in 7, \n",
    "        # add \"up\" to the list\n",
    "        if (i % 7 == 0) or ((i - 7) % 10 == 0):\n",
    "            third_student_says.append(\"up\")\n",
    "        # Otherwise, add the number to the list\n",
    "        else:\n",
    "            third_student_says.append(i)\n",
    "        \n",
    "print(third_student_says)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 7.__ (The Locker Problem) A hallway has 1000 open lockers numbered 1 to 1000. There are 1000 students and every number from 1 to 1000 is assigned to a student. Student 1 goes and shuts every locker. Student 2 goes and changes the state of every locker with an even number (i.e. this student opens closed lockers and closes any open lockers). This process continues with student $k$ changing the state of every locker whose number is evenly divisible by $k$. Which of the lockers are closed at the end of the process? Write code to implement the closing and opening of lockers and see. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Locker 1 is closed.\n",
      "Locker 4 is closed.\n",
      "Locker 9 is closed.\n",
      "Locker 16 is closed.\n",
      "Locker 25 is closed.\n",
      "Locker 36 is closed.\n",
      "Locker 49 is closed.\n",
      "Locker 64 is closed.\n",
      "Locker 81 is closed.\n",
      "Locker 100 is closed.\n",
      "Locker 121 is closed.\n",
      "Locker 144 is closed.\n",
      "Locker 169 is closed.\n",
      "Locker 196 is closed.\n",
      "Locker 225 is closed.\n",
      "Locker 256 is closed.\n",
      "Locker 289 is closed.\n",
      "Locker 324 is closed.\n",
      "Locker 361 is closed.\n",
      "Locker 400 is closed.\n",
      "Locker 441 is closed.\n",
      "Locker 484 is closed.\n",
      "Locker 529 is closed.\n",
      "Locker 576 is closed.\n",
      "Locker 625 is closed.\n",
      "Locker 676 is closed.\n",
      "Locker 729 is closed.\n",
      "Locker 784 is closed.\n",
      "Locker 841 is closed.\n",
      "Locker 900 is closed.\n",
      "Locker 961 is closed.\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "# Initialize a list of 1000 entries representing the\n",
    "# state of each locker. In the beginning, all locker are open.\n",
    "state = ['open' for i in range(1, 1001)]\n",
    "\n",
    "# Go through all the students\n",
    "for student in range(1, 1001):\n",
    "    \n",
    "    # Each student does something to the lockers\n",
    "    for locker in range(1, 1001):\n",
    "        if locker % student == 0: \n",
    "            if state[locker - 1] == 'open':\n",
    "                state[locker - 1] = 'closed'\n",
    "            elif state[locker - 1] == 'closed':\n",
    "                state[locker - 1] = 'open'\n",
    "\n",
    "# Print the numbers of the lockers that are closed\n",
    "# after all 1000 students do their thing\n",
    "for locker in range(1, 1001):\n",
    "    if state[locker - 1] == 'closed':\n",
    "        print(f\"Locker {locker} is closed.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Do you see a pattern in which lockers are open? Write your notes here. Double-click to edit._\n",
    "\n",
    "The closed lockers are those with square numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 8.__ Write code that sets the variable `time` to `1155` and another variable `half` to either `'am'` or `'pm'`. Now write code that converts this time to 24 hour zulu time, stores the result in a variable `zulu` and writes a sentence to the screen, such as \"1155 pm is equivalent to 2355 zulu time.\"\n",
    "\n",
    "Your code should produce the correct answer in both cases (am or pm). What should the output be when `time = 1245` and `half = pm`? Recall that pm stands for the Latin expression post meridiem (after midday). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1155 pm is equivalent to 2355 in zulu time.\n"
     ]
    }
   ],
   "source": [
    "# Write your code here for 1155\n",
    "time = 1155\n",
    "half = 'pm'\n",
    "\n",
    "if half == 'pm' and time < 1200:\n",
    "    zulu = time + 1200\n",
    "elif half == 'pm' and time > 1200:\n",
    "    zulu = time\n",
    "elif half == 'am' and time >=1200:\n",
    "    zulu = time -1200\n",
    "else: \n",
    "    zulu = time\n",
    "    \n",
    "print(f\"{time} {half} is equivalent to {zulu} in zulu time.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1245 pm is equivalent to 1245 in zulu time.\n"
     ]
    }
   ],
   "source": [
    "# Write your code here for 1245\n",
    "time = 1245\n",
    "half = 'pm'\n",
    "\n",
    "if half == 'pm' and time < 1200:\n",
    "    zulu = time + 1200\n",
    "elif half == 'pm' and time > 1200:\n",
    "    zulu = time\n",
    "elif half == 'am' and time >=1200:\n",
    "    zulu = time -1200\n",
    "else: \n",
    "    zulu = time\n",
    "    \n",
    "print(f\"{time} {half} is equivalent to {zulu} in zulu time.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Problem 9.__ Here's a fun way to try to estimate $\\pi$. Consider a circle of radius 1 sitting inside a square of side length 2 centered at the origin, as in the image below. \n",
    "<img width=400 src=\"img/pi.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First import the `random` package. Once you've done that, `random.uniform(-1, 1)` will generate a random value between -1 and 1.\n",
    "\n",
    "Using `for` loops, generate 10,000 random points in the xy-plane inside the square between (-1, -1) and (1, 1). _Hint. You can represent these points with 2 lists, one with the x-coordinates, and one with the y-coordinates._\n",
    "\n",
    "Now count the number of random points you generated are in the circle. _Hint. What equation does $(x,y)$ need to satisfy in order to be inside the circle?_\n",
    "\n",
    "We expect the proportion to be approximately equal to the ratio of the area of the circle to the area of the square, $\\pi/4$. Multiply your observed proportion by 4 to get an estimate of $\\pi$.\n",
    "\n",
    "How accurate is your estimate? What can you do to make it more accurate? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our approximation to pi using 10000 points is 3.1488.\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "import random as random\n",
    "\n",
    "# Here are two list comprehensions that generate the x and y points.\n",
    "# You can use the .append() technique too.\n",
    "x_points = [random.uniform(-1,1) for i in range(10000)]\n",
    "y_points = [random.uniform(-1,1) for i in range(10000)]\n",
    "\n",
    "# Initialize the number of points in the circle to be 0\n",
    "in_circle = 0\n",
    "\n",
    "# Check if each point is in the circle\n",
    "for i in range(0, 10000):\n",
    "    if x_points[i]**2 + y_points[i]**2 <= 1: \n",
    "        in_circle += 1\n",
    "        \n",
    "# Compute approximation of pi\n",
    "pi_approx = 4 * in_circle / 10000\n",
    "print(f\"Our approximation to pi using 10000 points is {pi_approx}.\")"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}