worksheet_intro/worksheet_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "34de13919d410054cbe5582af6bc1a0e",
     "grade": false,
     "grade_id": "cell-c319d5531db1ecc9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Worksheet 1: Introduction to Data Science\n",
    "\n",
    "Welcome to DSCI 100: Introduction to Data Science!  \n",
    "\n",
    "Each week you will complete a lecture assignment like this one. Before we get started, there are some administrative details.\n",
    "\n",
    "You can't learn technical subjects without hands-on practice. The weekly lecture worksheets and tutorials are an important part of the course. The lecture worksheets and tutorials will automatically be collected on the due date. Attendance in lectures and tutorials are required. There will be participatory activities in both the lecture and tutorial to help support your learning.\n",
    "\n",
    "- The lecture worksheets: \n",
    "    - Each question is worth 1 point. \n",
    "- The tutorial assignments: \n",
    "    - Each autograded question is worth 1 point. \n",
    "    - Each manually graded question is worth 3 points. \n",
    "\n",
    "Collaborating on lecture worksheets and tutorial assignments is more than okay -- it's encouraged! You should rarely be stuck for more than a few minutes on questions in lecture or tutorial, so ask a neighbor, TA or an instructor for help (explaining things is beneficial, too -- the best way to solidify your knowledge of a subject is to explain it). Please don't just share answers, though. Everyone must submit a copy of their own work.\n",
    "\n",
    "### Lecture and Tutorial Learning Goals:\n",
    "\n",
    "After completing this week's lecture and tutorial work, you will be able to:\n",
    "\n",
    "* use a Jupyter notebook to execute provided R code\n",
    "* edit code and markdown cells in a Jupyter notebook\n",
    "* create new code and markdown cells in a Jupyter notebook\n",
    "* load the `tidyverse` library into R\n",
    "* create new variables and objects in R using the assignment symbol\n",
    "* use the help and documentation tools in R\n",
    "* match the names of the following functions from the `tidyverse` library to their documentation descriptions: \n",
    "    - `read_csv` \n",
    "    - `select`\n",
    "    - `mutate`\n",
    "    - `filter`\n",
    "    - `ggplot`\n",
    "    - `aes`\n",
    "\n",
    "In this first worksheet you will also learn how to test the answers you write in this worksheet to assess if you answered questions correctly before your assignment is collected.\n",
    "\n",
    "This worksheet covers parts of [the Introduction chapter](https://datasciencebook.ca/intro.html) of the online textbook. In most worksheets we expect you to read the textbook chapters before completing the worksheet, however we know that might not have been possible for this worksheet, so we have added a bit more help to get you through. You still should however read the chapter to get a deeper understanding of this week's material (it will help you more easily answer the problems in this week's tutorial homework). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Jupyter Notebooks\n",
    "This webpage is called a Jupyter notebook. A notebook is a place to write computer code for analysis, view the results of the analysis, as well as to narrate the analysis with rich formatted text.\n",
    "\n",
    "### 1.1. 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 called [Markdown](http://daringfireball.net/projects/markdown/syntax) to add formatting and section headings.  You don't need to learn Markdown, but you might want to.\n",
    "\n",
    "After you edit a text cell, click the \"run cell\" button at the top that looks like ▶ to confirm any changes. (Try not to delete the instructions of the lab.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 1.1.1**\n",
    "<br> {points: 0}\n",
    "\n",
    "This paragraph is in its own text cell.  Try editing it so that all of the sentences following this one are deleted, then click the \"run cell\" ▶ button .  This sentence, for example, should be deleted.  So should this one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1f24d0021b81117baa013f8bfe309834",
     "grade": false,
     "grade_id": "cell-2cbb99dd62c103cf",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.2. Code Cells\n",
    "Other cells contain code in the R language. Running a code cell will execute all of the code it contains.\n",
    "\n",
    "To run the code in a cell, first click on that cell to activate it.  It will be highlighted with a blue rectangle to the left of it when activated.  Next, either press Run ▶ or hold down the `shift` key and press `return` or `enter`.\n",
    "\n",
    "Try running the next cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "13885cb373d9b039d26dbc26d3d2cba3",
     "grade": false,
     "grade_id": "cell-574a5de59726616e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "The above code cell contains a single line of code, but cells can also contain multiple lines of code. When you run a cell, the lines of code are executed in the order in which they appear. Every `print` expression prints a line. Run the next cell and notice the order of the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"First this line is printed,\")\n",
    "print(\"and then this one.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3e2ec2e190da547729b05e121753375d",
     "grade": false,
     "grade_id": "cell-e31e69275e504eaf",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 1.2.1**\n",
    "<br> {points: 0}\n",
    "\n",
    "Change the cell above so that it prints out:\n",
    "\n",
    "    First this line is printed,\n",
    "    and then the next line, \n",
    "    and then this one.\n",
    "\n",
    "*Hint:* If you're stuck for more than a few minutes, try talking to a neighbor or a TA.  That's a good idea for any worksheet or tutorial problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "6897102606c41643a9edcb5f10e3d52a",
     "grade": false,
     "grade_id": "cell-8aca6ad5dad1686e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.3. Writing Jupyter 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 of this tab.  The newly created cell will start out as a code cell.  You can change it to a text cell by clicking inside it so it's highlighted, clicking the drop-down box next to the restart and runall button (⏩) in the menu bar of this tab, and changing it from \"Code\" to \"Markdown\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0f3f01d569fe661fee8c629e3ac26225",
     "grade": false,
     "grade_id": "cell-2b1e70d0f7e41015",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.3.1**\n",
    "<br> {points: 0}\n",
    "\n",
    "Add a code cell below this one.  Write code in it that prints out:\n",
    "   \n",
    "    A whole new code cell!\n",
    "\n",
    "Run your cell to verify that it works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9fbcf76d1b027c4b6c1fdd2a3981b657",
     "grade": false,
     "grade_id": "cell-c04bf875f2a12581",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 1.3.2**\n",
    "<br> {points: 0}\n",
    "\n",
    "Add a text/Markdown cell below this one. Write the text \"A whole new Markdown cell\" in it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "2ce4201c96aa3512b4873d03b22e21ca",
     "grade": false,
     "grade_id": "cell-c5c60290d3773405",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.4. Comments\n",
    "Below you see lines like this in code cells:\n",
    "\n",
    "    # Test cell; please do not change!\n",
    "\n",
    "That is called a *comment*.  It doesn't make anything happen in R; R ignores anything on a line after a #.  Instead, it's there to communicate something about the code to you, the human reader.  Comments are extremely useful and can help increase how readable our code is.\n",
    "\n",
    "<img src=\"http://imgs.xkcd.com/comics/future_self.png\">\n",
    "\n",
    "*Source: https://xkcd.com/1421/*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "6a59db41fa0a8aa84db7d45b240547d6",
     "grade": false,
     "grade_id": "cell-149a0da6376111df",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "The below code cell contains comments (one at the start of a line, and one after some other code). Run the cell. You will see that everything after a comment symbol `#` is ignored by R."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "355fc8123da5f5d255772a7aa824db24",
     "grade": false,
     "grade_id": "cell-d263d4a012cce20f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# you can use comments to document your code, or make R ignore some code without deleting it entirely\n",
    "# print(\"this is a commented line that R will ignore. You won't see this text in the output!\")\n",
    "\n",
    "print(\"hello!\") # you can also put comments at the end of a line of code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "d5875bc18ed6c24efb525d9178c84301",
     "grade": false,
     "grade_id": "cell-01ff81a348979cec",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.5. Errors\n",
    "R is a language, and like natural human languages, it has rules.  It differs from natural language in two important ways:\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 R code is not smart enough to do that.\n",
    "\n",
    "Whenever you write code, you'll make mistakes (everyone who writes code does, even your course instructor!).  When you run a code cell that has errors, R will sometimes produce error messages to tell you what you did wrong.\n",
    "\n",
    "Errors are totally okay; even experienced programmers make many errors. It's a natural part of the coding process.  When you make an error, you just have to find the source of the problem, fix it, and move on. \n",
    "\n",
    "We have made an error in the next cell. **Remove the `#` symbol below (i.e., uncomment the line)**, and then run the cell to see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(\"This line is missing something.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8e966d64ce2b099ddaff488ca685f240",
     "grade": false,
     "grade_id": "cell-4f6f0bd2089ae34a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "![ws1_error_image.png](images/ws1_error_image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "cdedea1f6c7fec9f185a5db57f1b64de",
     "grade": false,
     "grade_id": "cell-d9a398f720c15d72",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "There's a lot of terminology in programming languages, but you don't need to know it all in order to program effectively. Even though the error message can seem cryptic, if you read it carefully you'll often find hints as to what went wrong. For example, above, you'll see the message `unexpected end of input` (among a lot of other technical jargon). In other words, R reached the end of the line of code, and wasn't expecting to reach the end -- it thinks there is still something missing!\n",
    "\n",
    "Of course, even if you do your best to interpret the error message, sometimes you may get stuck figuring out what went wrong and how to fix it. In that case, ask a neighbor or a TA 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": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8f4241b8bbeef3c7dda9b7212283348b",
     "grade": false,
     "grade_id": "cell-c766f54e33d7ddfd",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.6 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",
    "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",
    "1. At the top of your screen, click **Kernel**, then **Interrupt Kernel**.\n",
    "2. If that doesn't help, click **Kernel**, then **Restart Kernel...**. 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 Notebook**. Next, from the **File** menu click **Hub Control Panel**. Choose **Stop My Server** to shut it down, then **My Server** to start it back up. Then, navigate back to the notebook you were working on. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "bb62e8646075284f0b48c226124a30b6",
     "grade": false,
     "grade_id": "cell-0c2073834e4ed6ef",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.7 Saving your work\n",
    "\n",
    "Its important to save your work often so you don't lose your progress! At the top of the screen, go to the **File** menu then **Save Notebook**. There is also a disk icon (<img src=\"images/disk.png\" width=\"2%\">) in the menu of this tab that can be used to save your work as well. Finally, there are keyboard shorcuts for saving your work too: control + s on Windows, or command + s on Mac. Once you've saved your work, you will see a message at the bottom of the screen that says **Saving completed**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b2f343d4dc456f77d9f48b7f0bd9d4ed",
     "grade": false,
     "grade_id": "cell-608f48be6e011d77",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.8 Submitting your work\n",
    "All lecture worksheets and tutorials assignments in the course will be distributed as notebooks like this one. You will complete your work in this notebook and at the due date we will copy this notebook and grade that copy. For lecture worksheets we will use a system called nbgrader that checks your work. For tutorial assignments we will use a combination of nbgrader and manual grading of your work. \n",
    "\n",
    "**Play the Youtube video below to see how to properly answer questions and save in DSCI100 worksheets or tutorials.** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2135047d2bc67d07693fde1f59bb0fb3",
     "grade": false,
     "grade_id": "cell-a885a60c0b329543",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Run this cell and play the Youtube video below to see how to properly answer questions in DSCI100 worksheets or tutorials.\n",
    "\n",
    "IRdisplay::display_html('<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/M8W0HbzcK8Q\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fbe9d790638b4d3e1a4ba08df6142e37",
     "grade": false,
     "grade_id": "cell-9ed6ce9388e8f832",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 2. Numbers\n",
    "\n",
    "Quantitative information arises everywhere in data science. In addition to representing commands to print out lines, our R code 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": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3001d816535a6584cad5b8ec3708f09a",
     "grade": false,
     "grade_id": "cell-5be28374d3259816",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "3.2500"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9ba1f25b5ba44e049c73f0abbd3e12f2",
     "grade": false,
     "grade_id": "cell-99c0173419c4c036",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Notice that we didn't have to write `print()`. When you run a notebook cell, Jupyter helpfully prints out that value for you. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e55f6b37540c006c1f8d01be09c612e3",
     "grade": false,
     "grade_id": "cell-cb2a46a8043f465a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "2\n",
    "3\n",
    "4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "30fa340c769b680f99df9717a48c4603",
     "grade": false,
     "grade_id": "cell-428e0aa320f9d71c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Above, you should see that the three numbers (2, 3, and 4) are printed out. In R, simply inputting numbers and running the cell will generate all the numbers that you listed. Even though we don't need to use print, we will continue to do in several places in these worksheets so that we are very clear with our intentions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f668ffa33bd8fd3bc9322d6310bfbd9f",
     "grade": false,
     "grade_id": "cell-e6ef7b912b1d6466",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 2.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": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e2e353e10676c5be2c0d174ed7cc7eab",
     "grade": false,
     "grade_id": "cell-dc812dbbf6709655",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "2.0 - 1.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c63ecbbff4ca96ef7e36d3b8c6124e50",
     "grade": false,
     "grade_id": "cell-7561a7f5381f57ab",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Same with the cell below. Run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b5810fdc9bfc46610a9a15b484d9bfc2",
     "grade": false,
     "grade_id": "cell-a979051a6ec06143",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "2 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1adf39475d7f22dca8f2474c22611015",
     "grade": false,
     "grade_id": "cell-4c84cbf2f3818c52",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Many basic arithmetic operations are built in to R.  [This webpage](https://www.statmethods.net/management/operators.html) describes all the arithmetic operators used in the course.  You can refer back to this webpage as you need throughout the term. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "08c4f3887566078e3ad94b4cc16d89dd",
     "grade": false,
     "grade_id": "cell-0409bd1dafbd5607",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 3. Names\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",
    "Similarly, an effective strategy for writing code is to define names for data as we compute it, like a lawyer would define terms for complex ideas at the start of a legal document to simplify the rest of the writing.\n",
    "\n",
    "In R, we do this with *objects*. An object has a name on the left side of an `<-` sign and an expression to be evaluated on the right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3eb4fc00c23811669e14429ded2786f2",
     "grade": false,
     "grade_id": "cell-21477be239bb4840",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "answer <- 3 * 2 + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5af10a424408c07638315b1a8437bec5",
     "grade": false,
     "grade_id": "cell-4658369421769cf9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "When you run that cell, R first evaluates the first line.  It computes the value of the expression `3 * 2 + 4`, which is the number 10.  Then it gives that value the name `answer`.  At that point, the code in the cell is done running.\n",
    "\n",
    "After you run that cell, the value 10 is bound to the name `answer`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f4b7c933a630c9487063ec4303c913ab",
     "grade": false,
     "grade_id": "cell-15a8f76b9be881b8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "afad7561836880ac6eae27a9c4c92e78",
     "grade": false,
     "grade_id": "cell-f4a510b6a4bca3ff",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "We can name our objects anything we'd like. Above we called it `answer`, but we could have named it `value`, `data` or anything else we desired. A good rule of thumb is to name it something that has meaning to a human as it relates to what we are trying to accomplish with our R code.\n",
    "\n",
    "**Question 3.1**\n",
    "<br> {points: 0}\n",
    "\n",
    "Enter a new code cell. Try creating another object using `<- 3 * 2 + 4` with a name different from `answer`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "49b0f3345a37de506619ff51159a13e4",
     "grade": false,
     "grade_id": "cell-3077a3de9fe077a1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "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": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "72f3c951a4e2054bbc6bebc1b2182064",
     "grade": false,
     "grade_id": "cell-78f97b92c1be01a6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "close_to_pi <- 355/113\n",
    "close_to_pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "757fd7e8540b3e164a26b146ad37dcea",
     "grade": false,
     "grade_id": "cell-b478e69fabca22ac",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "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": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1a2733af2bae428a6efa1a75d107d20d",
     "grade": false,
     "grade_id": "cell-a0cbaa049db18fb5",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "bimonthly_salary <- 840\n",
    "monthly_salary <- 2 * bimonthly_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": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "00a591f8dbe265bc4927d4114fa5e811",
     "grade": false,
     "grade_id": "cell-8c609fe0a1239d4b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "When naming objects in R there are some rules:\n",
    "1. Names in R can have letters (upper- and lower-case letters are both okay and count as different letters e.g. \"Answer\" and \"answer\" will be treated as different objects), underscores, dots, and numbers. \n",
    "2. The first character can't be a number (otherwise a name might look like a number).  \n",
    "3. 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 R*.  For example, the next cell does the same thing as the above cell, except everything has a different name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "dd502ade154e593239653573602e18f1",
     "grade": false,
     "grade_id": "cell-dea627f3aa145226",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "a <- 840\n",
    "b <- 2 * a\n",
    "c <- 12\n",
    "d <- c * b\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "bfbf2af27ef267f484308ededff08fba",
     "grade": false,
     "grade_id": "cell-471f1c6d51994994",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "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",
    "There is also cultural style associated with different programming languages. In the modern R style, object names should use only lowercase letters, numbers, and `_`. Underscores (`_`) are typically used to separate words within a name (*e.g.*, `answer_one`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ba335b937440eb255b32823d6342b388",
     "grade": false,
     "grade_id": "cell-3922cab025333cea",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 3.2** <br> {points: 1}\n",
    "\n",
    "Assign the name `seconds_in_an_hour` to the number of seconds in an hour. You should do this in two steps. In the first, you calculate the number of seconds in a minute and assign that number the name `seconds_in_a_minute`. Next you should calculate the number of seconds in an hour and assign that number the name `seconds_in_an_hour.`  \n",
    "\n",
    "*Hint - there are 60 seconds in a minute and 60 minutes in a hour*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5aecce00fb84e0a0450a08b20ca368a7",
     "grade": false,
     "grade_id": "cell-25fc8c6b3679078e",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer\n",
    "\n",
    "# We've put this line in this cell so that it will print\n",
    "# the value you've given to seconds_in_an_hour when you\n",
    "# run it.  You don't need to change this.\n",
    "seconds_in_an_hour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8feaf0e4ab3fd51c526e4604a690efd3",
     "grade": false,
     "grade_id": "cell-68f2a6ed1f896684",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "### 3.2. Checking your code\n",
    "\n",
    "Now that you know how to name things, you can start using the built-in *tests* to check whether your work is correct. To do this, you will need to run the cell below to set things up. In future worksheets and tutorial assignments you will see this cell at the very top of the notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bee56eed5221e20d4b0c4c3d52809c5d",
     "grade": false,
     "grade_id": "cell-acbf6dab5510396f",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "source(\"tests.R\")\n",
    "source(\"cleanup.R\")\n",
    "options(repr.matrix.max.rows = 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "815fe1f5d8d9670010d222a2a48c14e8",
     "grade": false,
     "grade_id": "cell-74ab6e4f567ce283",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "Below is an example of a test cell for Question 3.2 above (assesses whether you have assigned `seconds_in_an_hour` correctly). If you haven't, this test will tell you that your solution is incorrect. Try not to change the contents of the test cells. Resist the urge to just copy it, and instead try to adjust your expression. (Sometimes the tests will give hints about what went wrong...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bfdc0605fe1510d17f333c324003326b",
     "grade": true,
     "grade_id": "cell-97af4ddf95e278d8",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_3.2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c5a2912953e5e457113bbebce6bc7955",
     "grade": false,
     "grade_id": "cell-6a5dc8af818248d4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "For this first question we'll provide you the solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1ee8a26f72c9ca6ff7c4b130d224772f",
     "grade": false,
     "grade_id": "cell-b69c7571e8367455",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Calculate the number of seconds in an hour.\n",
    "\n",
    "#SOLUTION:\n",
    "seconds_in_a_minute <- 60\n",
    "seconds_in_an_hour <- seconds_in_a_minute * 60\n",
    "\n",
    "# We've put this line in this cell so that it will print\n",
    "# the value you've given to seconds_in_an_hour when you\n",
    "# run it.  You don't need to change this.\n",
    "seconds_in_an_hour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1a72994435779dfa23f13fa4a8dd25ce",
     "grade": false,
     "grade_id": "cell-87d8da8b767b431c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "*Note: All autograded questions with visible tests in this course are worth 1 point.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4bda65cb6dc43cf014d3adcf526c5afe",
     "grade": false,
     "grade_id": "cell-d3783fed09550056",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 4. Calling Functions\n",
    "\n",
    "The most common way to combine or manipulate values in R is by calling functions. R comes with many built-in functions that perform common operations.\n",
    "\n",
    "We used a function `print()` at the beginning of this notebook when we printed text from a code cell. Here we'll demonstrate using another function `toupper()` that converts text to uppercase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c93caca92610e317ea12e4b23ad28774",
     "grade": false,
     "grade_id": "cell-135f838b44b060e4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "greeting <- toupper(\"Why, hello there!\")\n",
    "greeting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5ff813b0dad199066d4dec560380852c",
     "grade": false,
     "grade_id": "cell-cf5c8936e2e63bc9",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 4.0** <br> {points: 1} \n",
    "\n",
    "Use the function `tolower` to change all the words in the following movie title to lower case text: \"The House with a Clock in Its Walls\" and assign the lower case text the name `title`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "405a7cf46b2d566503330604232c3968",
     "grade": false,
     "grade_id": "cell-7c01c5466d4b5492",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer\n",
    "title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f9890c3b7b2c3207534383b92ac3de4d",
     "grade": true,
     "grade_id": "cell-2e0be062dc511dfc",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_4.0()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "17373eeddef4e30a1b44fc76bec18025",
     "grade": false,
     "grade_id": "cell-209d57552a17ac44",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 4.1. Multiple Arguments\n",
    "Some functions take multiple arguments, separated by commas. For example, the built-in `max` function returns the maximum argument passed to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b7ccc26f1585f44952650dc7d2d8ec45",
     "grade": false,
     "grade_id": "cell-f0ec85f4874bea3c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "biggest <- max(2, 15, 4, 7)\n",
    "biggest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9767fc428e960fe5d5f4843f86e347da",
     "grade": false,
     "grade_id": "cell-fcbac757ee173375",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 4.1** <br> {points: 1}\n",
    "\n",
    "Use the `min` function to find the minumum value of the numbers in the cell above.\n",
    "\n",
    "Assign the value to an object called `smallest`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9f7049aed814178dd3a0464c348918c6",
     "grade": false,
     "grade_id": "cell-a33d6a8b0379419a",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer\n",
    "smallest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a7d56a0e03bf4ba2b49bc6f6674a9fd1",
     "grade": true,
     "grade_id": "cell-79f3e7108d700a7a",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_4.1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4b52a88d624af084a26b63d42585e8fc",
     "grade": false,
     "grade_id": "cell-79c1a030f59bd182",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 5. Packages\n",
    "R has many built-in functions, but we can also use functions that are stored within packages created by other R users. We are going to use a package, called `tidyverse`, to load, modify and plot data.\n",
    "This package has already been installed for you. Later in the course you will learn how to install packages so you are free to bring in other tools as you need them for your data analysis. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "28715315244221d32a8d746fe279d44a",
     "grade": false,
     "grade_id": "cell-c7caff512e906ce4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "To use the functions from a package you first need to load it using the `library` function. This needs to be done once per notebook (and a good rule of thumb is to do this at the very top of your notebook so it is easy to see what packages your R code depends on). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bd8f624a5625a8e5266a63d72799599e",
     "grade": false,
     "grade_id": "cell-cc8404c98f4eb4e4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "library(tidyverse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Note: it is normal and expected that a message is printed out after loading the tidyverse and some packages. Generally, this message let’s you know if functions from the different packages were loaded share the same name (which is confusing to R), and if so, which one you can access using just it’s name (and which one you need to refer the package name and the function name to refer to it, this is called masking). Additionally, the tidyverse is a special R package - it is a meta-package that bundles together several related and commonly used packages. Because of this it lists the packages it does the job of loading."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e5e6975efb1299c9534439e3e5462caf",
     "grade": false,
     "grade_id": "cell-35de5f808c706124",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 5.1** <br> {points: 1} \n",
    "\n",
    "Use the `library` function to load the `rvest` R package. This package can be used to scrape data from the web. Next week, there is an optional section where you can learn how to do this if you like!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b84efedd7bf9ac213c79d1ede76d305d",
     "grade": false,
     "grade_id": "cell-5f08382d9af3cfaf",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "61c8352cb0699ddedefccd62c846691a",
     "grade": true,
     "grade_id": "cell-716f95a0b81eaeb3",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_5.1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a56f45c126b07e2f7472f9b82a1832dd",
     "grade": false,
     "grade_id": "cell-af462712f7808358",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 6. Looking for Help\n",
    "\n",
    "No one, even experienced, professional programmers remember what every function does, nor do they remember every possible function argument/option. So both experienced and new programmers (like you!) need to look things up, A LOT! \n",
    "### 6.1. Help Files\n",
    "One of the most efficient places to look for help on how a function works is the R help files. Let’s say we wanted to pull up the help file for the `max()` function. We can do this by typing a question mark in front of the function we want to know more about. Run the cell below to find out more about `read_csv`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a7f93eb6051842fade03ee31f7136258",
     "grade": false,
     "grade_id": "cell-fd7b2031082f05d8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "?read_csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "dc92c65da489592c8876a049b0a57b34",
     "grade": false,
     "grade_id": "cell-e359839ada6826ad",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "At the very top of the file, you will see the function itself and the package it is in (in this case, it is base). Next is a description of what the function does. You’ll find that the most helpful sections on this page are “Usage”, “Arguments” and \"Examples\". \n",
    "\n",
    "- **Usage** gives you an idea of how you would use the function when coding--what the syntax would be and how the function itself is structured. \n",
    "- **Arguments** tells you the different parts that can be added to the function to make it more simple or more complicated. Often the “Usage” and “Arguments” sections don’t provide you with step by step instructions, because there are so many different ways that a person can incorporate a function into their code. Instead, they provide users with a general understanding as to what the function could do and parts that could be added. At the end of the day, the user must interpret the help file and figure out how best to use the functions and which parts are most important to include for their particular task. \n",
    "- The **Examples** section is often the most useful part of the help file as it shows how a function could be used with real data. It provides a skeleton code that the users can work off of."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f0dc93a46778928caa93e67a5c95b959",
     "grade": false,
     "grade_id": "cell-bbb782c1683ae5ec",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Beyond the R help files there are many resources that you can use to find help. [Stack overflow](https://stackoverflow.com/), an online forum, is a great place to go and ask questions such as how to perform a complicated task in R or why a specific error message is popping up. Oftentimes, a previous user will have already asked your question of interest and received helpful advice from fellow R users."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "08af81e6a5f83767f30f071287056d6d",
     "grade": false,
     "grade_id": "cell-fec5d58455ef453e",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 6.1** Multiple Choice:\n",
    "<br> {points: 1}\n",
    "\n",
    "Use `?read_csv` and read the **Description** section to answer the multiple choice question below. To answer the question assign the letter associated with the correct answer to a variable in the the code cell below:\n",
    "\n",
    "Which statement below is accurate?\n",
    "\n",
    "A. `read_csv2()` uses `;` for separators, instead of `,`\n",
    "\n",
    "B. `read_delim` is a special case of the `read_csv` function.\n",
    "\n",
    "C. These functions are useful for reading binary files, such as excel spreadsheets.\n",
    "\n",
    "D. European countries commonly use `:` as the decimal separator.\n",
    "\n",
    "*Assign your answer to an object called `answer6.1`. Make sure your answer is an uppercase letter and is surrounded by quotation marks (e.g. `\"F\"`).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0646a72a72438bbdf956c1850b95935f",
     "grade": false,
     "grade_id": "cell-28b4bdea9f5971be",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3063d68bdfe5208ade08cb2c0830c1c6",
     "grade": true,
     "grade_id": "cell-4ccabbb92ce3407f",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_6.1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4c6160d24a8361c1f386d13367413948",
     "grade": false,
     "grade_id": "cell-09b84839aa0d416a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 7. Tidyverse Functions \n",
    "\n",
    "Now that we have learned a little about Jupyter notebooks and R, let's load a real dataset into R and explore it. As we do this we will learn more about key data loading, wrangling and visualization functions in R. \n",
    "\n",
    "### Exercise: Data about Runners!\n",
    "Researchers, Vickers and Vertosick performed [a study in 2016](https://bmcsportsscimedrehabil.biomedcentral.com/articles/10.1186/s13102-016-0052-y) that aimed to identify what factors had a relationship with race performance of recreational runners so that they could better predict future 5 km, 10 km and marathon race times for individual runners. Such predictions (and knowing what drives these predictions) can help runners by suggesting changes they could make to modifiable factors, such as training, to help them improve race time. Unmodifiable factors that contribute to the prediction, such as age or sex, allow for fair comparisons to be made between different runners.\n",
    "\n",
    "Vickers and Vertosick reasoned that their study is important because all previous research done to predict races times has focused on data from elite athletes. This biased data set means that the predictions generated from them do not necessarily do a good job predicting race times for recreational runners (whose data was not in the dataset that was used to create the model that generates the predictions). Additionally, previous research focused on reporting/measuring factors that require special expertise or equipment that are not freely available to recreational runners. This means that recreational runners may not be able to put their characteristics/measurements for these factors in the race time prediction models and so they will not be able to obtain an accurate prediction, or a prediction at all (in the case of some models).\n",
    "\n",
    "To make a better model, Vickers and Vertosick performed a large survey. They put their survey on the news website [Slate.com](https://slate.com/) attached to a news story about race time prediction. They were able to obtain 2,497 responses. The survey included questions that allowed them to collect a data set that included: \n",
    "- age,\n",
    "- sex,\n",
    "- body mass index (BMI) (in kg/m^2),\n",
    "- whether they are an edurance runner or speed demon,\n",
    "- what type of shoes they wear,\n",
    "- what type of training they do,\n",
    "- race time for 2-3 races they completed in the last 6 months,\n",
    "- self-rated fitness for each race,\n",
    "- and race difficulty for each race.\n",
    "\n",
    "\n",
    "Let's now use this data to explore a question we might be interested in - is there a relationship between 10 km race time and body mass index (BMI) for men runners in this data set. This is an exploratory data analysis question because we stated we looking for a relationship between measurements within the single data set we have and are not interested in yet interpreting beyond it. We can answer this question by visualizing the data as a scatter plot using R.\n",
    "\n",
    "If, however we are not aiming to extend our findings to a broader population, make predictions, analyze cause or mechanics, we would need to state a different data analyis question and follow-up with different analytical methods to answer that question.\n",
    "\n",
    "To answer our exploratory question (is there a relationship between 10 km race time and body mass index (BMI) for men runners in this data set), we will need to do the following things in R:\n",
    "\n",
    "1. load the data set into R\n",
    "2. subset the data we are interested in visualizing from the loaded dataset\n",
    "3. create a new column to get the unit of time in minutes instead of seconds\n",
    "4. create a scatter plot using this modified data\n",
    "\n",
    "> *Note 1 - subsetting the data and converting from seconds to minutes is not absolutely required to answer our question, but it will give us practice manipulating data in R, and make our data tables and figures more readable.*\n",
    ">\n",
    "> *Note 2 - many historical datasets treated sex as a variable where the possible values are only binary: male or female. This representation in this question reflects how the data were historically collected and is not meant to imply that we believe that sex is binary.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3470a35bb77e5a25c6807d9120e26f1e",
     "grade": false,
     "grade_id": "cell-875182daecbe6f0f",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.0.1** Multiple Choice:\n",
    "<br> {points: 1}\n",
    "\n",
    "Which of the following will you *not* find included in Vickers and Vertosick's data set?\n",
    "\n",
    "A. age\n",
    "\n",
    "B. what each runner ate before the race \n",
    "\n",
    "C. body mass index\n",
    "\n",
    "D. self-rated fitness for each race\n",
    "\n",
    "\n",
    "\n",
    "*Assign your answer to an object called `answer7.0.1`. Make sure your answer is an uppercase letter and is surrounded by quotation marks (e.g. `\"F\"`).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0cb6d560357b8a20e6b671b5d14a72da",
     "grade": false,
     "grade_id": "cell-0a23c8103bc2b3d1",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "92cdda4e7b0a756faa421934f875c4a2",
     "grade": true,
     "grade_id": "cell-cff33f621c8766b0",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.0.1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "32f07c59ca298104bb1352da673bb107",
     "grade": false,
     "grade_id": "cell-1d81abf393413d9f",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.0.2** True or False: \n",
    "<br> {points: 1} \n",
    "\n",
    "The researchers compiled this data so that they could build better models to predict marathon race times. \n",
    "\n",
    "*Assign your answer to an object called `answer7.0.2`. Make sure your answer is in lowercase letters and is surrounded by quotation marks (e.g. `\"true\"` or `\"false\"`).* "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fcbf0e4e04e3d592e13de3779c833945",
     "grade": false,
     "grade_id": "cell-fb1251cde3e9d937",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d5e51452b2f5333fdb801502068f65ab",
     "grade": true,
     "grade_id": "cell-74b20285258a1627",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.0.2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5513d416817574a4b465ec838604431f",
     "grade": false,
     "grade_id": "cell-e36918dd5663c9dc",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.0.3** Multiple Choice: \n",
    "<br> {points: 1}\n",
    "\n",
    "What kind of graph will we be creating? Choose the correct answer from the options below. \n",
    "\n",
    "A. Bar Graph \n",
    "\n",
    "B. Pie Chart\n",
    "\n",
    "C. Scatter Plot\n",
    "\n",
    "D. Box Plot \n",
    "\n",
    "*Assign your answer to an object called `answer7.0.3`. Make sure your answer is an uppercase letter and is surrounded by quotation marks (e.g. `\"F\"`).* "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "532311491bfbee99ebbccb65010e92cd",
     "grade": false,
     "grade_id": "cell-7f040d5aa4ed234b",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "623a1e0bd3cc806ad5d82ad72478f16e",
     "grade": true,
     "grade_id": "cell-3fd5ce0f36d5dac8",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.0.3()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f1751dd0428dbdfe543f2ce77a94ea2d",
     "grade": false,
     "grade_id": "cell-349ee71863adfdcc",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 7.1. Reading Data\n",
    "\n",
    "Let's get started with our first step - loading the data set. The data set we are loading is called `marathon_small.csv` and it contains a subset of the data from the study described above. The file is in the same directory/folder as the file for this notebook. It is a comma separated file (meaning the columns are separated by the `,` character). We often refer to these files as `.csv`'s.\n",
    "\n",
    "\n",
    "```\n",
    "age,bmi,km5_time_seconds,km10_time_seconds,sex\n",
    "25.0,21.6221160888672,NA,2798,female\n",
    "41.0,23.905969619751,1210.0,NA,male\n",
    "25.0,21.6407279968262,994.0,NA,male\n",
    "35.0,23.5923233032227,1075.0,2135,male\n",
    "34.0,22.7064037322998,1186.0,NA,male\n",
    "45.0,42.0875434875488,3240.0,NA,female\n",
    "33.0,22.5182952880859,1292.0,NA,male\n",
    "58.0,25.2340793609619,NA,3420,male\n",
    "29.0,24.505407333374,1440.0,3240,male\n",
    "```\n",
    "\n",
    "We can use the `read_csv` function to do this. Below is an example of reading a `.csv` file that is in the same directory/folder as the file for the notebook that would be reading it in:\n",
    "\n",
    "<img src=\"images/ws1_read_csv_gen.png\" width=\"500\">\n",
    "\n",
    "*Note - the quotes around the filename are important and you will get an error if you forget them.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fa39bb57c284342f98be3f6fe6f6f197",
     "grade": false,
     "grade_id": "cell-fdce32634531f220",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.1.1** <br> {points: 1}\n",
    "\n",
    "Use the `read_csv()` function to load the data from the `marathon_small.csv` file into R. Save the data to an object called `marathon_small`. If you need additional help try `?read_csv` and/or ask your neighbours or the Instructional team for help."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8f49deedacdac1f3956e7c268f493d08",
     "grade": false,
     "grade_id": "cell-7375b9bbe05dcbdf",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "library(tidyverse)\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer\n",
    "marathon_small"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6fa7a47aeea8bb4def3ddef174bb33da",
     "grade": true,
     "grade_id": "cell-cc0d111865dbbfd7",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.1.1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "88625d34b7456a16cfce87dfd99cef73",
     "grade": false,
     "grade_id": "cell-3a98fa7023e1eb2b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "The pink output under the code cell above tells you a bit about what happened when `read_csv` read the data into R. It tells you that 5 columns were created (names: age, bmi, km5_time_seconds, km10_time_seconds and sex) as well as the type of the data in those columns (*e.g.*, number-type or text-type), specifically:\n",
    "\n",
    "- `col_double` means that the data in this column is a number-type, specifically real numbers (meaning that these values *can contain decimals*) \n",
    "- `col_integer` means that the data in this column is a number-type, specifically integers (whole numbers) \n",
    "- `col_character` means that the data in this column contains text (e.g., letter or words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "186fd5acae40c7c69bd223eb59388b22",
     "grade": false,
     "grade_id": "cell-74575171b5186f5a",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.1.2** Multiple Choice <br> {points: 1}\n",
    "\n",
    "From the list below, which is a valid way to store a data frame object read in from `read_csv` to an object in R?\n",
    "\n",
    "A. `data -> read_csv(\"example_file.csv\")`\n",
    "\n",
    "B. `data <- read_csv(\"example_file.csv\")`\n",
    "\n",
    "C. `data <- read_csv\"example_file.csv\"`\n",
    "\n",
    "D. `data <- read_csv(example_file.csv)`\n",
    "\n",
    "*Assign your answer to an object called `answer7.1.2`. Make sure your answer is an uppercase letter and is surrounded by quotation marks (e.g. `\"F\"`).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9c78be3e52faf110f952bb60635e2e56",
     "grade": false,
     "grade_id": "cell-c2db43ed33f5d5c4",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c3d556dce831260c132f8d4214a32f3d",
     "grade": true,
     "grade_id": "cell-5f666032bb4401b7",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.1.2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0a7084c4efc3cdeb1a72756530beb2e2",
     "grade": false,
     "grade_id": "cell-c86ffd29e1931471",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 7.2. Data frames\n",
    "\n",
    "The functions from the `tidyverse` package give us a special class of data frame, called a tibble. You will learn more about tibbles in later chapters. For now, just know that a tibble is a type of data frame and we can look at the structure of a tibble by simply writing its name to view the output. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "55ddf9aebb7753dda9151a1e592a1d7a",
     "grade": false,
     "grade_id": "cell-64b0a35ae6aeadf9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "marathon_small"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "df5f82ec2f740249af8f88806aa4e266",
     "grade": false,
     "grade_id": "cell-b3f2b56e33767bba",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "This returns the first 3 and last 3 rows of the data frame. \n",
    "\n",
    "```\n",
    "age\tbmi\tkm5_time_seconds\tkm10_time_seconds\tsex\n",
    "<dbl>\t<dbl>\t<dbl>\t<dbl>\t<chr>\n",
    "25\t21.62212\tNA\t2798\tfemale\n",
    "41\t23.90597\t1210\tNA\tmale\n",
    "25\t21.64073\t994\tNA\tmale\n",
    "⋮\t⋮\t⋮\t⋮\t⋮\n",
    "42\t23.74768\t1203\tNA\tmale\n",
    "23\t24.20903\t2040\tNA\tfemale\n",
    "58\t23.49177\t1304\t2819\tmale\n",
    "```\n",
    "By default, the first row of a data set is always the **header** that `read_csv` uses to label the column. Therefore, the first row contains descriptive names while the rows below contain the actual data. \n",
    "\n",
    "This only shows us a small portion of the data set. You can look at more of the data set by using the `print()` function and specifying the number of rows you want to print. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "79a5b917d0f16232786770950abc9668",
     "grade": false,
     "grade_id": "cell-bda5f5f62adef7f6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "print(marathon_small, n = 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7dd57dad7b8f2bfd2fff837250db5da7",
     "grade": false,
     "grade_id": "cell-a442887ec56a1b76",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "This shows us the first 50 rows of the data set. We could look at the entire data by changing the `n` argument but looking at many rows of data can be very long and unnecessary to look at. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8788ba201be6a109a3124f8ee2db0f94",
     "grade": false,
     "grade_id": "cell-5951b907829ad6e6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 7.2.1** <br> {points: 1}\n",
    "\n",
    "To know how many rows there really are, use the function `nrow()`. Replace the `fail()` with your line of code. Assign the number of rows to the object `number_rows`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "454780a02ca2a90e8097969ce20503e6",
     "grade": false,
     "grade_id": "cell-915a98df76c978e3",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer\n",
    "print(number_rows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6e831f442ad6273a1e4ba382bf1c3433",
     "grade": true,
     "grade_id": "cell-4b1ac4397c5243b7",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.2.1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "884419cb2577621de7ba023ae5dc85c0",
     "grade": false,
     "grade_id": "cell-edd0481e3bdd23c2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 7.3. Filter\n",
    "\n",
    "One of the most useful functions of `tidyverse` is `filter()`. With this function, it is possible to filter out specific observations based on their entries in one or more columns. \n",
    "\n",
    "For example, if we had a data set (named `data`) that looked like this:\n",
    "\n",
    "```\n",
    "  colour size speed\n",
    "1    red   15  12.3\n",
    "2   blue   19  34.1\n",
    "3   blue   20  23.2\n",
    "4    red   22  21.9\n",
    "5   blue   12  33.6\n",
    "6   blue   23  28.8\n",
    "```\n",
    "\n",
    "we could use the first line of the code in the image below to filter for rows where the colour has the value of \"blue\". The second line of code below would let us filter for rows where the size has a value greater than 20."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4346bbfbd9a17873b77e36c69a0b951b",
     "grade": false,
     "grade_id": "cell-ff80f8d1f2177f31",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "<img src=\"images/ws1_filter_gen.png\" width=\"500\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "40d90b7681e3ce2a046eb0b1a1d31a36",
     "grade": false,
     "grade_id": "cell-ddcf5f9aa839ad61",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.3.1** <br> {points: 1}\n",
    "\n",
    "Use the function `filter()` to subset your data frame `marathon_small` so it only contains survey data from males. Assign your new filtered data frame to an object called `marathon_filtered`. Replace the `fail()` with your line of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a93d982ca6f270e0c9ec62da9b09eb91",
     "grade": false,
     "grade_id": "cell-e7beff787df8a914",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer\n",
    "marathon_filtered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e5d0523f7a42b2255533c07debff0821",
     "grade": true,
     "grade_id": "cell-d291ec9d90db8b58",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.3.1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f76f852b7af61d976438b912e3c73e25",
     "grade": false,
     "grade_id": "cell-d72b21282995548a",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "### 7.4. Select\n",
    "\n",
    "The `select()` function allows you to zoom in and focus on specific parts of the data. It is particularly helpful when working with extremely large datasets. More specifically, the function allows you to separate one or more columns from your dataset and transfer them into their own data frame.\n",
    "\n",
    "Remembering our example `data`:\n",
    "\n",
    "```\n",
    "  colour size speed\n",
    "1    red   15  12.3\n",
    "2   blue   19  34.1\n",
    "3   blue   20  23.2\n",
    "4    red   22  21.9\n",
    "5   blue   12  33.6\n",
    "6   blue   23  28.8\n",
    "```\n",
    "\n",
    "For example, we can use the function `select()` to choose columns of interest (here colour and size). \n",
    "\n",
    "\n",
    "<img src=\"images/ws1_select_gen.png\" width=\"500\">\n",
    "\n",
    "\n",
    "and we would get this smaller data set back:\n",
    "\n",
    "```\n",
    "  colour size\n",
    "1    red   15\n",
    "2   blue   19\n",
    "3   blue   20\n",
    "4    red   22\n",
    "5   blue   12\n",
    "6   blue   23\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a1432acc6734699bd18c8802d48000f4",
     "grade": false,
     "grade_id": "cell-b0bc499f963dbec1",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.4.1** <br> {points: 1}\n",
    "\n",
    "Use the function `select` to choose the columns `bmi` and `km10_time_seconds` from `marathon_filtered`. Assign your new filtered data frame to an object called `marathon_male`. \n",
    "\n",
    "Replace the `fail()` with your line of code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "af8dc51ae18eadfa207c38f883e0fd5e",
     "grade": false,
     "grade_id": "cell-8c7d8d3d35e9c965",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer\n",
    "marathon_male"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "cf09bed463a6f4c9926dec149d1a478e",
     "grade": true,
     "grade_id": "cell-6ff43dbc0e4c101a",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.4.1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "bfa2b813d4121b46d10adaedfb502480",
     "grade": false,
     "grade_id": "cell-dc0e64aa1e498195",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.4.2** <br> {points: 1}\n",
    "\n",
    "What are the units of the time taken to complete a run of 10 km? Assign your answer to an object called `answer7.4.2`. Write your answer in lower case. Place your answer between quotation marks.\n",
    "\n",
    "\n",
    "*Hint: scroll up and look at the introduction to this exercise.* "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "14bcbe67f875515f1d7d152d0fe9464e",
     "grade": false,
     "grade_id": "cell-9427064af05d9e2d",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2e1d1e5b17daf26cfbb662adb5a924b9",
     "grade": true,
     "grade_id": "cell-c33482eddf0fb701",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.4.2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "30c8a263564200c12df87927c45640d7",
     "grade": false,
     "grade_id": "cell-349835037f2f8e16",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.4.3**\n",
    "<br> {points: 1}\n",
    "\n",
    "What are the units for time (e.g., seconds, minutes, hours) that we would like to use when plotting BMI against time taken to run 10 km? Assign your answer to an object called `answer7.4.3`. Write your answer in lower case. Place your answer between quotation marks.\n",
    "\n",
    "*Hint: scroll up and look at the introduction to this exercise.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c6be229280a002a0c525e81ad2cb526d",
     "grade": false,
     "grade_id": "cell-61ce351a65c7e90a",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2fd61475d05e423448e77a1b35f5fc36",
     "grade": true,
     "grade_id": "cell-d928ed8dbb3b1432",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.4.3()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fe75aad3f34ebda85305b79de7da8b38",
     "grade": false,
     "grade_id": "cell-84b07686e39b9b60",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 7.5. Mutate\n",
    "\n",
    "The function `mutate()` is used to add columns to a dataset, typically by making use of existing columns to compute a new column. \n",
    "\n",
    "<img src=\"images/ws1_mutate_gen.png\">\n",
    "\n",
    "In the example above, we are creating a new column named `new_column` that is equal to `old_column * 10` and saving the results to an object called `data_mutated`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "65b3e4607d4ea82c753f5656d26b3d8c",
     "grade": false,
     "grade_id": "cell-58260d4833281498",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.5.1**<br> {points: 1}\n",
    "\n",
    "Add a new column to our `marathon_male` dataset called `km10_time_minutes` that is equal to `km10_time_seconds/60.` Assign your answer to an object called `marathon_minutes`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "86bee1fffac6d33076e6c4d52f8ecc00",
     "grade": false,
     "grade_id": "cell-a98350d5aa8b2c63",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer\n",
    "marathon_minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7015c1a87524ece19bff10baa5c13954",
     "grade": true,
     "grade_id": "cell-88b400e7b47a3b10",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.5.1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "24821f1083607f377ec2fcb288085573",
     "grade": false,
     "grade_id": "cell-188153dcf97bb1df",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "### 7.6. Graphing\n",
    "`ggplot` is a function that works using layers of code. Every time you want to see something new added to your plot, you must add a new layer with each layer being separated by the “+” symbol. The first function we use in this line of code is the `ggplot` function. Here, we indicate the arguments that apply to all layers of the plot. The second function we use is `geom_point()`. This function indicates that we wish to produce a scatterplot and the way we wish to display the data within this scatterplot. \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "![ws1_ggplot_male.png](images/ws1_ggplot_male.png)\n",
    "\n",
    "Let's plot a scatterplot with the `bmi` on the x axis and `km5_time_minutes` on the y axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9472e5c7cb137b0da9a0ac1274176262",
     "grade": false,
     "grade_id": "cell-562a1d0acb301acb",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# code to set-up plot size\n",
    "library(repr)\n",
    "options(repr.plot.width=8, repr.plot.height=7) #play with width/height to make the plot below a reasonable size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "232bf7bd4ca38565cefbb6c58b411c45",
     "grade": false,
     "grade_id": "cell-6d4ad14b6ac5a665",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Run this cell to create a scatterplot of BMI against the time it took to run 10 km. \n",
    "ggplot(data = marathon_minutes, aes(x = bmi, y = km10_time_minutes)) + \n",
    "    geom_point() + \n",
    "    theme(text = element_text(size=20)) #play with the size value to change the text size in the plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We also use the `options()` function to set the size of the plot, and the `theme()` function to control the size of the text in the plot. Note that using the `options()` function sets the default plot size for the whole notebook, while the `theme()` function only sets the font size for the current plot created by `ggplot`. So later on in the notebook we will create another plot, but we will only use `theme()` -- we won't use `options()` again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1b7fcd2ab3d95c5c1ee6583eef3e1972",
     "grade": false,
     "grade_id": "cell-bdc859bb78a43c42",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "**Question 7.6.1** Multiple Choice\n",
    "<br> {points: 1}\n",
    "\n",
    "Looking at the graph above, choose a statement above that most reflects what we see.\n",
    "\n",
    "A. There appears to be no relationship between 10 km run time and body mass index. As the value for body mass index increases we see neither an increase nor decrease in the time it takes to run 10 km.\n",
    "\n",
    "B. There may be a positive relationship between 10 km run time and body mass index. As the value for body mass index increases, so does the time it takes to run 10 km.\n",
    "\n",
    "C. There may be a negative relationship between 10 km run time and body mass index. As the value for body mass index increases, the time it takes to run 10 km decreases.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "*Assign your answer to an object called `answer7.6.1`. Make sure your answer is an uppercase letter and is surrounded by quotation marks (e.g. `\"F\"`).*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7a1b6cb4c269c965a8044ef906ffbddc",
     "grade": false,
     "grade_id": "cell-3294e67b2ac425f7",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Replace the fail() with your answer. \n",
    "\n",
    "# your code here\n",
    "fail() # No Answer - remove if you provide an answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8c3402d380953e5ba970e0f4ee9a44cc",
     "grade": true,
     "grade_id": "cell-f79260c10ed592af",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "test_7.6.1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7df1494fd6b51e73439eca171240dd28",
     "grade": false,
     "grade_id": "cell-394e4e671a2beef3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "The code we listed above for graphics barely scratches the surface of what ggplot, and R as a whole, are capable of. Not only are there far more choices about the kinds of plots available, but there are many, many options for customizing the look and feel of each graph. You can choose the font, the font size, the colors, the style of the axes, etc. \n",
    "\n",
    "Let’s dig a little deeper into just a couple of options that you can add to any of your graphs to make them look a little better. For example, you can change the text of the x-axis label or the y-axis label by using `xlab(\"\")` or `ylab(\"\")`. Let’s do that for the scatterplot to make the labels easier to read.\n",
    "\n",
    "*Notice the formatting of the cell.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell. \n",
    "# You can replace the axes with whatever you wish to label. \n",
    "# After running the cell once, try changing the axes to something else. \n",
    "\n",
    "ggplot(data = marathon_minutes, aes(x = bmi, y = km10_time_minutes)) + \n",
    "    geom_point() + \n",
    "    xlab(\"Body Mass Index\") + \n",
    "    ylab(\"10 km run time (minutes)\") +\n",
    "    theme(text = element_text(size = 20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b7628012928595266063c1cd03fda3d7",
     "grade": false,
     "grade_id": "cell-c2e761c4721e274f",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "## Attributions\n",
    "- UC Berkeley [Data 8 Public Materials](https://github.com/data-8/data8assets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5c3a1dc66de60cc6d0d9d446f56f9447",
     "grade": false,
     "grade_id": "cell-40f2e5b73bb5a1ec",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "source(\"cleanup.R\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "4.3.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}