delong-jn-00.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an interactive jupyter notebook document.\n",
    "\n",
    "Page down through it, following the instructions…\n",
    "\n",
    "With what looks to be a permanent and long-run partial moving-online of the university, the already important topic of “data science” seems likely to become even more foundational.  Hence this first problem set tries to provide you with an introduction—to “data science”, and to the framework we will be using for problem sets that we hope will make things much easier for you and for us…\n",
    "\n",
    "When you are finished, satisfied, or stuck, print your notebook to pdf, & upload the pdf to the appropriate assignment bCourses page: <https://bcourses.berkeley.edu/courses/1505111/assignments/8326533>\n",
    "\n",
    "Also, please include with your submission all of your comments on and reactions to this assignment that you want us to know...\n",
    "    \n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": [
    "# Jupyter Notebook 00. Introduction to Python & Notebooks\n",
    "\n",
    "These computer programming problem set assignments are a required part of the course.\n",
    "\n",
    "Collaborating on the problem sets is more than okay—it is encouraged! Seek help from a classmate or an instructor or a roommate or a passerby when you get stuck! (Explaining things is beneficial, too—the best way to solidify your knowledge of a subject is to explain it.) \n",
    "\n",
    "But the work has to be your own: no cutting-&-pasting from others' problem sets, please! We want you to learn this stuff, and your fingers typing every keystroke is an important way of building muscle memory here.\n",
    "\n",
    "In fact, we strongly recommend that as you work through this notebook, whenever you come to a \"code\" cell—something intended not for you to read but also to direct the computer—the python interpreter—to do calculations, you (1) click on the code cell to bring it into your browser's focus; (2) click on the `+` button in the toolbar above to create a new code cell just below the one you were now in; and then (3) retype, line-by-line, the computer code in the cell (not the comment lines beginning with `#`s, but the code cells) while trying to figure out what the line of code is intended to tell the python interpreter to do. \"Muscle\"—in this case, fingertip—memory is an important but undervalued part of \"active learning\" here at Berkeley. In Germany, however, they have a term for it: _das Fingerspitzengefühl_; it's the kind of understanding-through-the-fingertips that a true expert has.\n",
    "\n",
    "In this problem set, you will learn how to:\n",
    "\n",
    "1. navigate Jupyter notebooks (like this one);\n",
    "2. write and evaluate some basic *expressions* in Python, the computer language of the course;\n",
    "3. call *functions* to use code other people have written; and\n",
    "4. break down python code into smaller parts to understand it.\n",
    "5. Do some initial data explorations with Python in a notebook.\n",
    "\n",
    "For reference, you might find it useful to read chapter 3 of the Data 8 textbook: <<http://www.inferentialthinking.com/chapters/03/programming-in-python.html>>. Chapters 1 <<https://www.inferentialthinking.com/chapters/01/what-is-data-science.html>> and 2 <<https://www.inferentialthinking.com/chapters/02/causality-and-experiments.html>> are worth skimming as well..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": [
    "## 1. Why Are We Doing This?\n",
    "\n",
    "First of all, we are doing this because our section leaders are overworked: teaching online takes more time and effort than teaching in person, and our section leaders were not overpaid before the 'rona arrived on these shores. Taking the bulk of the work of grading calculation assignments off of their backs is a plus—and it appears that the best way for us to do that is to distribute a number of the course assignements to you in this form: the form of a python computer language \"jupyter notebook\"\n",
    "\n",
    "Second, we are doing this because learning jupyter notebooks and python may well turn out to be the intellectual equivalent for you of \"eat your spinach\": something that may seem unpleasant and unappetizing now, but that makes you stronger and more capable. In 1999 Python programming language creator Guido van Rossem compared to the coming of literacy and writing itself the coming of the ability to read, write, and use software you had built or modified yourself to search and analyze data and information collection. Guido speculated that mass programming literacy and competence, if it could be attained, would produce increases in societal power and changes in societal organization of roughly the same magnitude as mass literacy has had over the past several centuries. Guido may be right, and he may be wrong. But what is clear is that your lives may be richer, and you may have more options, if the data science and basic programming intellectual tools become a useful part of your intellectual panoplies.\n",
    "\n",
    "An analogy: Back in the medieval European university, people would learn the trivium—the “trivial” subjects of grammar (how to write), rhetoric (how to speak in public), and logic (how to think coherently)—then they would learn the quadrivium of arithmetic, geometry, music/harmony, and astronomy/astrology; and last they would learn the advanced and professional subjects: law or medicine or theology and phyics, metaphysics, and moral philosophy. But a student would also learn two more things: how to learn by reading—how to take a book and get something useful out of it, without a requiring a direct hands-on face-to-face teacher; and (2) how to write a _fine chancery hand_ so that they could prepare their own documents, for submission to secular courts or to religious bishops or even just put them in a form where they would be easily legible to any educated audience back in those days before screens-and-attachments, before screens-and-printers, before typewriters, before printing.\n",
    "\n",
    "The data science tools may well turn out to be in the first half of the 2000s the equivalent of a _fine chancery hand_, just as a facility with the document formats and commands of the Microsoft office suite were the equivalent of a _fine chancery hand_ at the end of the 1900s: practical, general skills that make you of immense value to most if not nearly all organizations. This—along with the ability to absorb useful knowledge without requiring hands-on person-to-person face-to-face training—will greatly boost your social power and your set of opportunities in your life. If we are right about its value.\n",
    "\n",
    "Third, why Jupyter and Python, rather than R-Studio and R, or C++ and MATLAB, or even (horrors!) Microsoft Ezcel? Because Jupyter Project founder Fernando Perez has an office on the fourth floor of Evans. Because half of Berkeley undergraduates currently take Data 8 and so, taking account of other channels, more than half of Berkeley students are already going to graduate literate in python.\n",
    "\n",
    "Let us get started!\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Jupyter Notebooks\n",
    "\n",
    "This browser window is now showing you a computer science object that is called a \"Jupyter notebook\". A notebook is a place to write programs and view their results, and also to write text. The text and programs are contained in little boxes called \"cells\". When the computer thinks that you are paying attention to a particular cell—and may click in it, and then edit it—it surrounds the cell with a blue box, and puts a blue line to the left of the cell.\n",
    "\n",
    "A notebook is an editable document object in which you can write computer programs; view their results; and comment, annotate, and explain what is going on. Project jupyter <https://en.wikipedia.org/wiki/Project_Jupyter> is headquartered here at Berkeley, where jupyter originator and ringmaster Fernando Pérez <https://en.wikipedia.org/wiki/Fernando_Pérez_(software_developer)> works: its purpose is to build human-friendly frameworks for interactive computing. If you want to see what Fernando looks and sounds like, you can load and watch a 15-minute inspirational video by clicking on the line 'YouTubeVideo(\"Wd6a3JIFH0s\")' in the cell immediately below this one, and then clicking on the '▶' symbol in the toolbar at the top of the sub-window this cell appears in: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "\n",
    "# The original URL is: \n",
    "# https://www.youtube.com/watch?v=Wd6a3JIFH0s\n",
    "\n",
    "YouTubeVideo(\"Wd6a3JIFH0s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1. Code Cells\n",
    "\n",
    "The _cell_ directly above this one contains four lines of code in the Python 3 computer language. You _ran_ these four lines as a program—the computer _executed_ the instructions the cell containss—when you clicked on the '▶' symbol in the toolbar at the top of this sub-window. (You could also have run the cell by, when the computer has focused on it by your clicking on it, pressing 'shift-return' or 'control-return' on your keyboard.) a code cell will execute all of the code it contains.\n",
    "\n",
    "The first line of the cell immediately above is a _Pytnon expression_: it tells the computer to enlarge the set of Python commands it understands by finding the 'YouTubeVideo' command in the 'IPython.display' external library of commands, and then importing that command into its memory. Once it has done that, you can then ask the computer to execute that command—which then constructs a little YouTube video window and plays a YouTube video in it. You ask the computer to do so the in the fourth line of the code cell. Which YouTube video does the computer play? You tell it by writing, after 'YouTubVideo' a '(', then a '\"', then the reference ID of the video, then another '\"', and then, finally, a ')'.\n",
    "\n",
    "Between the first and the last lines of the code cell are two lines that are _comment lines_. Anything on a line that comes after a '#' symbol the computer takes to be a comment—something directed at humans, and not at computers, that it should ignore. The comment lines tell you—us—what the URL is for the video that the fourth line is going to command the computer to play.\n",
    "\n",
    "The cell also contains two blank lines. They are just there to give your eyes and brain visual clues to where to look for information, and thus make code cells easier to read.\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "Now try running this cell immediately below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and this one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\\N{WAVING HAND SIGN}, \\N{EARTH GLOBE ASIA-AUSTRALIA}!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every 'print' expression commands the computer to print a line of symbols to the screen. Directions as to what is in the line of symbols that it prints are contained between the '(' and the ')' that follow the initial Python command 'print' on the expression line.\n",
    "\n",
    "The first of the two code cells above that you just ran is the standard first computer program to write, either if you are a new student or if you are testing out a new machine or testing out writing in a new programming language. it tells the computer to print out to the screen the symbols 'Hello, World!' What did the second code cell print to the screen, and why?\n",
    "\n",
    "Within a code cell, each 'print' statement's output is printed to the screen on a separate line. The lines are arranged in the order in which the computer, scanning from the top to the bottom of the code cell, encounters the lines.\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2. Text cells\n",
    "In a notebook, each rectangle containing text or code is called a *cell*.\n",
    "\n",
    "Text cells (like this one) can be edited by double-clicking on them. They're written in a simple format created by Jon Gruber called **markdown** <<http://daringfireball.net/projects/markdown/syntax>> to add formatting and section headings. You almost surely want to learn how to use markdown.\n",
    "\n",
    "After you edit a text cell, click the 'run cell' button at the top that looks like '▶' in the toolbar at the top of this window, or press 'shift-return' on your keyboard to confirm any changes to the text and formatting. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": [
    "**Question 2.2.1.** This paragraph is in its own text cell.  Try editing it so that this sentence is the last sentence in the paragraph, and then click the 'run cell' ▶| button or 'shift-return'. This sentence, for example, should be deleted. So should this one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3. Writing notebooks\n",
    "You can use Jupyter notebooks for your own projects or documents.  When you make your own notebook, you'll need to create your own cells for text and code.\n",
    "\n",
    "To add a cell, click the + button in the menu bar.  It will start out as either a markdown text or a code cell.  You can change it to the other type by clicking inside it so it's highlighted, clicking the drop-down box to the left of 'Python 3' in the menu bar, and choosing either 'Code' or 'Markdown'.\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "**Question 2.3.1.** Add a code cell below this one.  Write code in it that prints out:\n",
    "   \n",
    "    A whole new cell! ♪🌏♪\n",
    "\n",
    "(That musical note symbol is like the Earth symbol.  Its long-form name is '\\N{EIGHTH NOTE}'.)\n",
    "\n",
    "Run your cell to verify that it works.\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4. \"Errors\"\n",
    "\n",
    "Python is a language, and like natural human languages, it has rules.  It differs from natural language in two important ways:\n",
    "\n",
    "1. The rules are *simple*.  You can learn most of them in a few weeks and gain reasonable proficiency with the language in a semester.\n",
    "2. The rules are *rigid*. If you're proficient in a natural language, you can understand a non-proficient speaker, glossing over small mistakes.  A computer running Python code is not smart enough to do that.\n",
    "\n",
    "Whenever you write code, you'll make mistakes.  When you run a code cell that has errors, Python will sometimes produce error messages to tell you what you did wrong.\n",
    "\n",
    "Errors are okay; even experienced programmers make many errors.  When you make an error, you just have to find the source of the problem, fix it, and move on.\n",
    "\n",
    "When you run code, you have the option to, in the window menubar, click 'Run > Run All Cells', which will run all the code cells in the notebook in order. However, the notebook stops running code cells if it hits an error.\n",
    "\n",
    "We have made an error in the next code cell.  Run it and see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(\"This line is missing something.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see something like this (minus our annotations):\n",
    "\n",
    "<img src=\"images/error.jpg\" width=\"600\" />\n",
    "\n",
    "The last line of the error output attempts to tell you what went wrong.  The *syntax* of a language is its structure, and this 'SyntaxError' tells you that you have created an illegal structure.  'EOF' means 'end of file', so the message is saying Python expected you to write something more (in this case, a right parenthesis) before finishing the cell.\n",
    "\n",
    "There's a lot of terminology in programming languages, but you don't need to know it all in order to program effectively. If you see a cryptic message like this, you can often get by without deciphering it.  (Of course, if you're frustrated, ask a neighbor or a staff member for help.)\n",
    "\n",
    "Try to fix the code above so that you can run the cell and see the intended message instead of an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "for_assignment_type": "solution"
   },
   "outputs": [],
   "source": [
    "print(\"This line is missing something.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5. The Kernel\n",
    "The kernel is a program that executes the code inside your notebook and outputs the results. In the top right of your window, you can see a circle that indicates the status of your kernel. If the circle is empty (⚪), the kernel is idle and ready to execute code. If the circle is filled in (⚫), the kernel is busy running some code. \n",
    "\n",
    "Next to every code cell, you'll see some text that says 'In [...]'. Before you run the cell, you'll see 'In [ ]'. When the cell is running, you'll see 'In [*]'. If you see an asterisk (\\*) next to a cell that doesn't go away, it's likely that the code inside the cell is taking too long to run, and it might be a good time to interrupt the kernel (discussed below). When a cell is finished running, you'll see a number inside the brackets, like so: 'In [1]'. The number corresponds to the order in which you run the cells; so, the first cell you run will show a 1 when it's finished running, the second will show a 2, and so on. \n",
    "\n",
    "You may run into problems where your kernel is stuck for an excessive amount of time, your notebook is very slow and unresponsive, or your kernel loses its connection. If this happens, try the following steps:\n",
    "\n",
    "1. At the top of your screen, click **Kernel**, then **Interrupt**.\n",
    "2. If that doesn't help, click **Kernel**, then **Restart**. If you do this, you will have to run your code cells from the start of your notebook up until where you paused your work.\n",
    "3. If that doesn't help, restart your server. First, save your work by clicking **File** at the top left of your screen, then **Save and Checkpoint**. Next, click **Control Panel** at the top right. Choose **Stop My Server** to shut it down, then **Start My Server** to start it back up. Then, navigate back to the notebook you were working on. You'll still have to run your code cells again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6. Libraries\n",
    "There are many add-ons and extensions to the core of python that are useful—indeed essential—to using it to get work done. They are contained in what are called libraries. The rest of this notebook needs three libraries. So let us tell the python interpreter to install them. Run the code cell below to do so: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# install the numerical python, python data analysis, and mathematical\n",
    "# plotting libraries for python\n",
    "\n",
    "!pip install numpy\n",
    "!pip install pandas\n",
    "!pip install matplotlib\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib as mpl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Python: Numbers & Variables\n",
    "\n",
    "Jupyter notebooks can, of course, consist of much more than mere commands to print out lines. Expressions can represent numbers and methods of combining numbers. The expression '3.2500' evaluates to the number 3.25. Run the cell and see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3.2500"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we didn't have to 'print'. When you run a notebook cell, if the last line has a value, then Jupyter helpfully prints out that value for you. \n",
    "\n",
    "However, it won't print out prior lines automatically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(2)\n",
    "3\n",
    "4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, you should see that 4 is the value of the last expression, 2 is printed because it is within the scope of the print command, but 3 is lost forever because it was neither printed nor last.\n",
    "\n",
    "You don't want to print everything all the time anyway.  But if you feel sorry for 3, change the cell above to print it.\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1. Arithmetic\n",
    "The line in the next cell subtracts.  Its value is what you'd expect.  Run it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3.25 - 1.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many basic arithmetic operations are built into Python.  The textbook section on [Expressions](http://www.inferentialthinking.com/chapters/03/1/expressions.html) describes all the arithmetic operators used in the course.  The common operator that differs from typical math notation is '\\*\\*', which raises one number to the power of the other. **NOT '^'.** Thus '2**3' stands for $2^3$ and evaluates to 8. \n",
    "\n",
    "The order of operations and parenthesers is the same as what you learned in elementary school. For example, compare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3+6*5-6*3**2*2**3/4*7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4+(6*5-(6*3))**2*((2**3)/4*7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In standard math notation, the first expression is\n",
    "\n",
    ">$3 + 6 \\times 5 - 6 \\times 3^2 \\times \\frac{2^3}{4} \\times 7$,\n",
    "\n",
    "while the second expression is\n",
    "\n",
    ">$3 + (6 \\times 5 - (6 \\times 3))^2 \\times (\\frac{(2^3)}{4} \\times 7)$.\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "**Question 3.1.1.** Write a Python expression in the next code cell that's equal to:\n",
    "\n",
    ">$5 \\times (3 \\frac{10}{11}) - 50 \\frac{1}{3} + 2^{.5 \\times 22} - \\frac{7}{33} + 3$\n",
    "\n",
    "That is: five times three and ten elevenths, minus fifty and a third, plus two to the power of half twenty-two, minus seven thirty-thirds plus three.  By '$3 \\frac{10}{11}$' we mean:\n",
    "\n",
    ">$3+\\frac{10}{11}$, \n",
    "\n",
    "not:\n",
    "\n",
    ">$3 \\times \\frac{10}{11}$.\n",
    "\n",
    "Replace the ellipses (`...`) with your expression.  Try to use parentheses only when necessary.\n",
    "\n",
    "*Hint:* The correct output should start with a familiar number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2. Variables\n",
    "In natural language, we have terminology that lets us quickly reference very complicated concepts.  We don't say, \"That's a large mammal with brown fur and sharp teeth!\"  Instead, we just say, \"Bear!\"\n",
    "\n",
    "In Python, we do this with *assignment statements*. An assignment statement has a name on the left side of an '=' sign and an expression to be evaluated on the right. To see how this works, note that if you have just started or restarted this notebook, the following code line produces an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'ten' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-e4edfb673989>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mten\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'ten' is not defined"
     ]
    }
   ],
   "source": [
    "ten"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But suppose you run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ten = 3 * 2 + 4\n",
    "\n",
    "print(ten)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you run that cell, Python first computes the value of the expression on the right-hand side, '3 * 2 + 4', which is the number 10. After you run that first line, the value 10 is bound to the name 'ten': write 'ten', and the computer will understand it as a metaphorical box that contains the number 10. So when you command the computer to print out whatever is in the box named 'ten', it will print the number '10': "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The line of code 'ten = 3 * 2 + 4' thus changes what 'ten' means; it now refers to the value 10, whereas before it meant nothing at all.\n",
    "\n",
    "If the designers of Python had been ruthlessly pedantic, they might have made us write\n",
    "\n",
    "    define the name ten to hereafter have the value of 3 * 2 + 4 \n",
    "\n",
    "instead.  You will probably appreciate the brevity of '='! But keep in mind that this is the real meaning. '=' does not assert or declare that what is on the left is equal to whqt is on the right. Rather, it takes what is on the right and stuffs it into the metaphorical box which has the name on the left.\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A common pattern in Jupyter notebooks is to assign a value to a name and then immediately evaluate the name in the last line in the cell so that the value is displayed as output. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "close_to_pi = 355/113\n",
    "close_to_pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another common pattern is that a series of lines in a single cell will build up a complex computation in stages, naming the intermediate results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "semimonthly_salary = 841.25\n",
    "monthly_salary = 2 * semimonthly_salary\n",
    "number_of_months_in_a_year = 12\n",
    "yearly_salary = number_of_months_in_a_year * monthly_salary\n",
    "yearly_salary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Names in Python can have letters (upper- and lower-case letters are both okay, and count as different letters), underscores, and numbers.  The first character can't be a number (otherwise a name might look like a number).  And names can't contain spaces, since spaces are used to separate pieces of code from each other.\n",
    "\n",
    "Other than those rules, what you name something doesn't matter *to Python*.  For example, this cell does the same thing as the above cell, except everything has a different name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 841.25\n",
    "b = 2 * a\n",
    "c = 12\n",
    "d = c * b\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**However**, *names are very important for making your code readable* to yourself and others.  The cell above is shorter, but it's totally useless without an explanation of what it does.\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3. Application: A Physics Experiment\n",
    "\n",
    "On the Apollo 15 mission to the Moon, astronaut David Scott replicated Galileo's physics experiment. He showed that gravity accelerates objects of different mass at the same rate. Because there is no air resistance for a falling object on the surface of the Moon, even two objects with very different masses and densities should fall at the same rate. David Scott compared a feather and a hammer.\n",
    "\n",
    "You can run the following cell to watch a video of the experiment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "# The original URL is: \n",
    "# https://www.youtube.com/watch?v=U7db6ZeLR5s\n",
    "\n",
    "YouTubeVideo(\"U7db6ZeLR5s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the transcript of the video:\n",
    "\n",
    ">**167:22:06 Scott**: Well, in my left hand, I have a feather; in my right hand, a hammer. And I guess one of the reasons we got here today was because of a gentleman named Galileo, a long time ago, who made a rather significant discovery about falling objects in gravity fields. And we thought where would be a better place to confirm his findings than on the Moon. And so we thought we'd try it here for you. The feather happens to be, appropriately, a falcon feather for our Falcon. And I'll drop the two of them here and, hopefully, they'll hit the ground at the same time. \n",
    "\n",
    ">**167:22:43 Scott**: How about that!\n",
    "\n",
    ">**167:22:45 Allen**: How about that! (Applause in Houston)\n",
    "\n",
    ">**167:22:46 Scott**: Which proves that Mr. Galileo was correct in his findings.\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Newton's Law.** Using this footage, we can also attempt to confirm another famous bit of physics: Newton's law of universal gravitation. Newton's laws predict that any object dropped near the surface of the Moon should fall\n",
    "\n",
    ">$$\\frac{GM}{2R^2} t^2 \\text{ meters}$$\n",
    "\n",
    "after $t$ seconds, where $G$ is a universal constant, $M$ is the moon's mass in kilograms, and $R$ is the moon's radius in meters.  So if we know $G$, $M$, and $R$, then Newton's laws let us predict how far an object will fall over any amount of time.\n",
    "\n",
    "To verify the accuracy of this law, we will calculate the difference between the predicted distance the hammer drops and the actual distance.  (If they are different, it might be because Newton's laws are wrong, or because our measurements are imprecise, or because there are other factors affecting the hammer for which we haven't accounted.)\n",
    "\n",
    "Someone studied the video and estimated that the hammer was dropped 113 cm from the surface. Counting frames in the video, the hammer falls for 1.2 seconds (36 frames).\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 3.3.1.** Complete the code in the next cell to fill in the data from the experiment.\n",
    "\n",
    "*Hint:* No computation required; just fill in data from the paragraph above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# time t, the duration of the fall in the experiment, in seconds.\n",
    "# Replace the ellipsis (\"...\") in the line below with your \n",
    "# estimate of the duration of the fall\n",
    "\n",
    "time = ...\n",
    "\n",
    "# The estimated distance the hammer actually fell, in meters.\n",
    "\n",
    "# Replace the ellipsis (\"...\") in the line below with your \n",
    "# estimate of the length of the fall\n",
    "\n",
    "estimated_distance_m = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 3.3.2.** Now, complete the code in the next cell to compute the difference between the predicted and estimated distances (in meters) that the hammer fell in this experiment.\n",
    "\n",
    "This just means translating the formula above ($\\frac{1}{2}G\\frac{M}{R^2}t^2$) into Python code.  You'll have to replace each variable in the math formula with the name we gave that number in Python code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, we've written down the values of the 3 universal constants \n",
    "# that show up in Newton's formula.\n",
    "\n",
    "# G, the universal constant measuring the strength of gravity.\n",
    "gravity_constant = 6.674 * 10**-11\n",
    "\n",
    "# M, the moon's mass, in kilograms.\n",
    "moon_mass_kg = 7.34767309 * 10**22\n",
    "\n",
    "# R, the radius of the moon, in meters.\n",
    "moon_radius_m = 1.737 * 10**6\n",
    "\n",
    "# The distance the hammer should have fallen \n",
    "# over the duration of the fall, in meters, \n",
    "# according to Newton's law of gravity.  \n",
    "# The text above describes the formula\n",
    "# for this distance given by Newton's law.\n",
    "\n",
    "# **YOU FILL THIS PART IN.**\n",
    "predicted_distance_m = ...\n",
    "\n",
    "# Here we've computed the difference \n",
    "# between the predicted fall distance and the distance we actually measured.\n",
    "# If you've filled in the above code, this should just work.\n",
    "difference = predicted_distance_m - estimated_distance_m\n",
    "difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4. Lists\n",
    "\n",
    "Lists and their siblings, numpy arrays, are ordered collections of objects that have an order. Lists allow us to store groups of variables under one name. The order then allows us to access the objects in the list for easy access and analysis. If you want an in-depth look at the capabilities of lists, take a look at <<https://www.tutorialspoint.com/python/python_lists.htm>>\n",
    "\n",
    "To initialize a list, you use brackets. Putting objects separated by commas in between the brackets will add them to the list. For example, we can create and name an empty list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "list_example = []\n",
    "print(list_example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add an object to the end of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5]\n"
     ]
    }
   ],
   "source": [
    "list_example = list_example + [5]\n",
    "print(list_example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have a one-element list. And we can add another element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 10]\n"
     ]
    }
   ],
   "source": [
    "list_example = list_example + [10]\n",
    "print(list_example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to make a two-element list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can join—\"concatenate\"—two lists together:\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 10, 1, 3, 6, 'lists', 'are', 'fun', 4]\n"
     ]
    }
   ],
   "source": [
    "list_example_two = list_example + [1, 3, 6, 'lists', 'are', 'fun', 4]\n",
    "print(list_example_two)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**Digression**: It is, I think, a mistake for python to use '+' in this way. In arithmetic, '+' is simply addition. With lists, '+' smashes the two lists on either side together to make a bigger list. this 'overloading' of '+' can be a source of great confusion. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This '4' is a number: 4 ; so '+' is addition and so 4 + 4 = 8\n",
      " \n",
      "This '4' is a list: [4] ; so '+' is list concatenation and so [4] + [4] = [4, 4]\n",
      " \n",
      "Even worse is: this '4' is a string-of-symbols: 4 ; so '+' is symbol concatenation and so 4 + 4 = 44\n"
     ]
    }
   ],
   "source": [
    "# overloading of the `+` operator considered harmful:\n",
    "\n",
    "four = 4\n",
    "print(\"This '4' is a number:\", four, \"; so '+' is addition and so\", four, \"+\", four, \"=\", four + four)\n",
    "print(\" \")\n",
    "\n",
    "four = [4]\n",
    "print(\"This '4' is a list:\", four, \"; so '+' is list concatenation and so\", four, \"+\", four, \"=\", four + four)\n",
    "print(\" \")\n",
    "\n",
    "four = '4'\n",
    "print(\"Even worse is: this '4' is a string-of-symbols:\", four, \"; so '+' is symbol concatenation and so\", four, \"+\", four, \"=\", four + four)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access not the list as a whole but an individual value in the list, simply count from the start of the list, and put the place of the object you want to access in brackets after the name of the list. \n",
    "\n",
    "**But you have to start counting from not one but zero.** \n",
    "\n",
    "Thus the initial object of a list has index 0, the second object of a list has index 1, and in the list above the eighth object has index 7:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fun\n"
     ]
    }
   ],
   "source": [
    "selected_example = list_example_two[7]\n",
    "print(selected_example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which is indeed the eighth item of 'list_example_two'.\n",
    "\n",
    "You may have noticed already that lists do not have to be made up of elements of the same kind. \n",
    "\n",
    "Indices do not have to be taken one at a time, either. Instead, we can take a 'slice;\\' of indices, and return the elements at those indices as a separate list. \n",
    "\n",
    "Suppose we just want to select out items 4 through 6 from a list. We can do so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_list = list_example_two[4:7]\n",
    "print(selected_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can select out the largest and smallest items of a list via `min` and `max`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max of a_list: 13\n",
      "Min of b_list: 1\n"
     ]
    }
   ],
   "source": [
    "# A list containing six integers.\n",
    "a_list = [1, 6, 4, 8, 13, 2]\n",
    "\n",
    "# Another list containing six integers.\n",
    "b_list = [4, 5, 2, 14, 9, 11]\n",
    "\n",
    "print('Max of a_list:', max(a_list))\n",
    "print('Min of b_list:', min(a_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy arrays are siblings of lists that can be operated on arithmetically with much more versatility than regular lists. Let us start by making an array that consists of the numbers from zero to nine:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example Array: [0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "example_array = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "print(\"Example Array:\", example_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This could have been accomplished more quickly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Undoubled Array:  [0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "example_array_2 = np.arange(10)\n",
    "print('Another Example Array: ', example_array_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplying a list and an array by a number produce different results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplying a list by 2:  [4, 5, 2, 14, 9, 11, 4, 5, 2, 14, 9, 11]\n",
      "Multiplying an array by 2:  [ 8 10  4 28 18 22]\n"
     ]
    }
   ],
   "source": [
    "b_list = [4, 5, 2, 14, 9, 11]\n",
    "print('Multiplying a list by 2: ', 2 * b_list)\n",
    "\n",
    "b_array = np.array([4, 5, 2, 14, 9, 11])\n",
    "print('Multiplying an array by 2: ', 2 * b_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Programming\n",
    "\n",
    "### 4.1. Looping\n",
    "Loops <<https://www.tutorialspoint.com/python/python_loops.htm>> are  useful in manipulating, iterating over, or transforming large lists and arrays. The __for loop__ is useful in that it travels through a list, performing an action at each element. The following code cell moves through every element in example_array, adds it to the previous element in example_array, and copies this sum to a new array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = []\n",
    "\n",
    "for element in example_array:\n",
    "    new_element = element + 5\n",
    "    new_list.append(new_element)\n",
    "\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most important line in the above cell is the 'for element in...' line. This statement sets the structure of our  loop, instructing the machine to stop at every number in `example_array`, perform the indicated operations, and then move on. Once Python has stopped at every element in 'example_array', the loop is completed and the final line, which outputs 'new_list', is executed. \n",
    "\n",
    "Note that we did not have to use the exact word 'element' to refer to whichever index value the loop is currently operating on. We could have called it almost anything. \n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "newer_list = []\n",
    "\n",
    "for completely_arbitrary_name in example_array:\n",
    "    newer_element = completely_arbitrary_name + 5\n",
    "    newer_list.append(newer_element)\n",
    "    \n",
    "print(newer_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For loops can also iterate over ranges of numerical values. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(example_array)):\n",
    "    example_array[i] = example_array[i] + 5\n",
    "\n",
    "print(example_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The __while loop__ repeatedly performs operations until a condition is no longer satisfied. Consider the example below. When the program enters the while loop, it notices that the maximum value of the while_array is less than 50. Because of this, it adds 1 to the fifth element, as instructed. \n",
    "\n",
    "The program then goes back to the start of the loop. Again, the maximum value is less than 50. This process repeats until the the fifth element, now the maximum value of the array, is equal to 50, at which point the condition is no longer true, and the python interpreter moves on to the \"print\" command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while_array = np.arange(10)        # Generate our array of values\n",
    "\n",
    "print('Before:', while_array)\n",
    "\n",
    "while(max(while_array) < 50):      # Set our conditional\n",
    "    while_array[4] += 1            # Add 1 to the fifth element if the conditional is satisfied \n",
    "    \n",
    "print('After:', while_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2. Functions\n",
    "\n",
    "The most common way to combine or manipulate values in Python is by calling functions. Python comes with many built-in functions that perform common operations.\n",
    "\n",
    "For example, the `abs` function takes a single number as its argument and returns the absolute value of that number. Run the next two cells and see if you understand the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": [
    "**Example: computing walking distances**: Chunhua is on the corner of 7th Avenue and 42nd Street in Midtown Manhattan, and she wants to know far she'd have to walk to get to Gramercy School on the corner of 10th Avenue and 34th Street.\n",
    "\n",
    "She can't cut across blocks diagonally, since there are buildings in the way.  She has to walk along the sidewalks.  Using the map below, she sees she'd have to walk 3 avenues (long blocks) and 8 streets (short blocks).  In terms of the given numbers, she computed 3 as the difference between 7 and 10, *in absolute value*, and 8 similarly.  \n",
    "\n",
    "Chunhua also knows that blocks in Manhattan are all about 80m by 274m (avenues are farther apart than streets).  So in total, she'd have to walk $(80 \\times |42 - 34| + 274 \\times |7 - 10|)$ meters to get to the park.\n",
    "\n",
    "<img src=\"images/map.jpg\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": [
    "**Question 4.2.1.** Fill in the line 'num_avenues_away = ...' in the next cell so that the cell calculates the distance Chunhua must walk and gives it the name 'manhattan_distance'.  Everything else has been filled in for you.  **Use the 'abs' function.** Also, be sure to run the test cell afterward to test your code.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# Here's the number of streets away:\n",
    "num_streets_away = abs(42-34)\n",
    "\n",
    "# Compute the number of avenues away in a similar way:\n",
    "num_avenues_away = ...\n",
    "\n",
    "street_length_m = 80\n",
    "avenue_length_m = 274\n",
    "\n",
    "# Now we compute the total distance Chunhua must walk.\n",
    "manhattan_distance = street_length_m*num_streets_away + avenue_length_m*num_avenues_away\n",
    "\n",
    "# We've included this line so that you see the distance you've computed \n",
    "# when you run this cell.  \n",
    "# You don't need to change it, but you can if you want.\n",
    "manhattan_distance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": [
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Multiple arguments**: Some functions take multiple arguments, separated by commas. For example, the built-in 'max' function returns the maximum out of all the arguments passed to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(2, -3, 4, -5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "### 4.3. Nested expressions\n",
    "Function calls and arithmetic expressions can themselves contain expressions.  You saw an example in the last question:\n",
    "\n",
    "    abs(42-34)\n",
    "\n",
    "has 2 number expressions in a subtraction expression in a function call expression.  And you probably wrote something like 'abs(7-10)' to compute 'num_avenues_away'.\n",
    "\n",
    "Nested expressions can turn into complicated-looking code. However, the way in which complicated expressions break down is very regular.\n",
    "\n",
    "Suppose we are interested in heights that are very unusual.  We'll say that a height is unusual to the extent that it's far away on the number line from the average human height.  [An estimate](http://press.endocrine.org/doi/full/10.1210/jcem.86.9.7875?ck=nck&) of the average adult human height (averaging, we hope, over all humans on Earth today) is 1.688 meters.\n",
    "\n",
    "So if Kayla is 1.21 meters tall, then her height is $|1.21 - 1.688|$, or $.478$, meters away from the average.  Here's a picture of that:\n",
    "\n",
    "<img src=\"images/numberline_0.png\" width=\"600\" />\n",
    "\n",
    "And here's how we'd write that in one line of Python code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(1.21 - 1.688)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's going on here? \n",
    "\n",
    "'abs' takes just one argument, so the stuff inside the parentheses is all part of that *single argument*.  Specifically, the argument is the value of the expression '1.21 - 1.688'.  The value of that expression is '-.478'.  That value is the argument to 'abs'.  The absolute value of that is '.478', so '.478' is the value of the full expression 'abs(1.21 - 1.688)'.\n",
    "\n",
    "Picture simplifying the expression in several steps:\n",
    "\n",
    "1. 'abs(1.21 - 1.688)'\n",
    "2. 'abs(-.478)'\n",
    "3. '.478'\n",
    "\n",
    "In fact, that's basically what Python does to compute the value of the expression.\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": [
    "**Question 4.3.1.** Say that Paola's height is 1.76 meters.  In the next cell, use 'abs' to compute the absolute value of the difference between Paola's height and the average human height.  Give that value the name 'paola_distance_from_average_m':\n",
    "\n",
    "<img src=\"images/numberline_1.png\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# Replace the ... with an expression \n",
    "# to compute the absolute value \n",
    "# of the difference between Paola's height (1.76m) and the average human height.\n",
    "paola_distance_from_average_m = ...\n",
    "\n",
    "# Again, we've written this here \n",
    "# so that the distance you compute will get printed \n",
    "# when you run this cell.\n",
    "paola_distance_from_average_m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now say that we want to compute the more unusual of the two heights.  We'll use the function 'max', which  returns the largest of its arguments.  Combining that with the `abs` function, we can compute the larger distance from average among the two heights:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just read and run this cell.\n",
    "\n",
    "kayla_height_m = 1.21\n",
    "paola_height_m = 1.76\n",
    "average_adult_height_m = 1.688\n",
    "\n",
    "# The larger distance from the average human height, among the two heights:\n",
    "larger_distance_m = max(abs(kayla_height_m - average_adult_height_m), abs(paola_height_m - average_adult_height_m))\n",
    "\n",
    "# Print out our results in a nice readable format:\n",
    "print(\"The larger distance from the average height among these two people is\", larger_distance_m, \"meters.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The line where 'larger_distance_m' is computed looks complicated, but we can break it down into simpler components just like we did before.\n",
    "\n",
    "The basic recipe is to repeatedly simplify small parts of the expression:\n",
    "\n",
    "* **Basic expressions:** Start with expressions whose values we know, like names or numbers.\n",
    "    - Examples: 'paola_height_m' or '5'.\n",
    "* **Find the next simplest group of expressions:** Look for basic expressions that are directly connected to each other. This can be by arithmetic or as arguments to a function call. \n",
    "    - Example: 'kayla_height_m - average_adult_height_m'.\n",
    "* **Evaluate that group:** Evaluate the arithmetic expression or function call. Use the value computed to replace the group of expressions.  \n",
    "    - Example: 'kayla_height_m - average_adult_height_m' becomes '-0.478'.\n",
    "* **Repeat:** Continue this process, using the value of the previously-evaluated expression as a new basic expression. Stop when we've evaluated the entire expression.\n",
    "    - Example: 'abs(-0.478)' becomes '0.478', and 'max(.478, .072)' becomes '.478'.\n",
    "\n",
    "You can run the next cell to see a slideshow of that process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "IFrame('https://docs.google.com/presentation/d/e/2PACX-1vTiIUOa9tP4pHPesrI8p2TCp8WCOJtTb3usOacQFPfkEfvQMmX-JYEW3OnBoTmQEJWAHdBP6Mvp053G/embed?start=false&loop=false&delayms=3000', 800, 600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false
   },
   "source": [
    "Ok, your turn:\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "**Question 4.3.2.** Given the heights of players from the Golden State Warriors, write an expression that computes the smallest difference between any of the three heights. Your expression shouldn't have any numbers in it, only function calls and the names 'klay', 'steph', and 'dangelo'. Give the value of your expression the name 'min_height_difference'.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false
   },
   "outputs": [],
   "source": [
    "# The three players' heights, in meters:\n",
    "klay =  2.01 # Klay Thompson is 6'7\"\n",
    "steph = 1.91 # Steph Curry is 6'3\"\n",
    "dangelo = 1.95 # D'Angelo Russell is 6'5\"\n",
    "             \n",
    "# We'd like to look at all 3 pairs of heights, \n",
    "# compute the absolute difference between each pair, \n",
    "# and then find the smallest of those 3 absolute differences.  \n",
    "# This is left to you!  \n",
    "# If you're stuck, try computing the value for each step of the process \n",
    "# (like the difference between Klay's heigh and Steph's height) \n",
    "# on a separate line and giving it a name (like klay_steph_height_diff)6\n",
    "min_height_difference = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&nbsp;\n",
    "\n",
    "That brings us to the end of the \"problem set\" portion of this jupyter notebook. The next two sections are much more in the mode of a data-science lecture than an exercise. Follow along to get a taste of the kind of data manipulation and visualization we will be doing using three python extensions: the numerical python, python data analysis, and mathematical plotting libraries 'numpy', 'pandas', and 'matplotlib':\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a much more human-readable presentation of the dataframe of calculated growth rates of the ideas stock, living standards of the typical human, and of the human population over the eras that make up human history...\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. You Are Done!\n",
    "\n",
    "You're done with Problem set 0!  Be sure to submit it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "Thanks to Umar Maniku, Eric van Dusen, Anaise Jean-Philippe, Marc Dordal i Carrerras, & others for helpful comments. Very substantial elements of this were borrowed from the Berkeley Data 8 <<http://data8.org>> teaching materials, specifically Lab 01: <https://github.com/data-8/materials-sp20/blob/master/materials/sp20/lab/lab01/lab01.ipynb>>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "## <font color=\"880000\"> Introduction to Python & Notebooks </font>\n",
    "\n",
    "<img src=\"https://tinyurl.com/20190119a-delong\" width=\"300\" style=\"float:right\" />\n",
    "\n",
    "### <font color=\"000088\">Catch Our Breath—Further Notes:</font>\n",
    "\n",
    "<br clear=\"all\" />\n",
    "\n",
    "----\n",
    "\n",
    "----\n",
    "\n",
    "**Introduction to Python & Notebooks: Links:** <<http://datahub.berkeley.edu/user-redirect/interact?account=braddelong&repo=delong-python-problem-sets&branch=main&path=delong-jn-00.ipynb>> <<https://github.com/braddelong/delong-python-problem-sets/blob/main/delong-jn-00.ipynb>> <<https://nbviewer.jupyter.org/github/braddelong/delong-python-problem-sets/blob/main/delong-jn-00.ipynb>>\n",
    "\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "----"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}