py_worksheet_intro/py_worksheet_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "22fbd44e-7905-4be2-b600-3335cc4577ef",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "30d7537cb6b5bbf151be1e888c4b2476",
     "grade": false,
     "grade_id": "cell-ab73bb44c9419adb",
     "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 are worth 5% of your final grade. \n",
    "    - Each question is worth 1 point. \n",
    "- The tutorial assignments are worth 15% of your final grade. \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 Python 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 `pandas` package into Python \n",
    "* create new variables and objects in Python\n",
    "* use the help and documentation tools in Python\n",
    "* perform the following operations from the `pandas` package:\n",
    "    - Read a standard .csv file using `read_csv`.\n",
    "    - subset rows and columns of a data frame using `loc[]`.\n",
    "    - select columns of a dataframe using `[]`.\n",
    "    - create a new column of a dataframe using `assign`.\n",
    "* use `Altair` package to create plots \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://python.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",
   "id": "918f6020-9762-46e2-a984-45f17d4bbcf0",
   "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",
   "id": "123e5c30-f998-4902-904b-89b8614e51ac",
   "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",
   "id": "fa461635-3e32-4f47-b224-1da3e30f8c32",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a3f9fb9fd681b9512391d2fe287c7224",
     "grade": false,
     "grade_id": "cell-1bcb95d0b1db3765",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.2. Code Cells\n",
    "Other cells contain code in the Python 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,
   "id": "921efaf9-1898-4714-abbe-d3e2c3f2a649",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a328045c-feb3-4b45-8f03-2159e6ed0a2a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "cfa55ff88b8edef774b86185d1f401c7",
     "grade": false,
     "grade_id": "cell-488f473e002dc27f",
     "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,
   "id": "e07a90fe-6165-49ee-8ef9-4a6908803eec",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"First this line is printed,\")\n",
    "print(\"and then this one.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6c36a89-fd46-45ee-999f-b06e02face86",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "a513fcdd41d7ad6f84648eae8e72b441",
     "grade": false,
     "grade_id": "cell-3e71ba8e076aadc4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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",
   "id": "b82fc076-e177-4222-a076-34bc99c00f7c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8b90ab900a0b98adbac88edf8b9ee2e0",
     "grade": false,
     "grade_id": "cell-9e9042f97b98984a",
     "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",
   "id": "ae421ba1-618e-4461-b02d-7af6df87a4d1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5541afe8b35cc69f02f5060873126689",
     "grade": false,
     "grade_id": "cell-83c7e7fa61f10648",
     "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",
   "id": "d69dec82-8a35-43ba-ac23-5275095fc5cd",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "2193d667364f4656d9ce4cb9a0365d1c",
     "grade": false,
     "grade_id": "cell-9bbc9bcea523bb72",
     "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",
   "id": "6329eb66-a8f0-4fcb-9705-9b5705c9e629",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1d00e79a45988af22528aff9bf1f3a40",
     "grade": false,
     "grade_id": "cell-bfb007543b14d1cb",
     "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 Python; Python 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",
   "id": "abf0f646",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "25d7e12237e87a3fdfc9b4e3eb09d8c6",
     "grade": false,
     "grade_id": "cell-75bfe4b544638250",
     "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 Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d6c61d3",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "526ff505505e36ff7b6136c354277c37",
     "grade": false,
     "grade_id": "cell-d093fd3fe06e79c6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# you can use comments to document your code, or make Python ignore some code without deleting it entirely\n",
    "# print(\"this is a commented line that Python 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",
   "id": "de1c67bb-15ce-49d4-b1b7-b263d1173a8d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "034981204275e7b44a9beefd7b0f16cb",
     "grade": false,
     "grade_id": "cell-849c6b93d0cacce4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.5. Errors\n",
    "Python 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 Python 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, Python will sometimes produce error messages to tell you what you did wrong.\n",
    "\n",
    "Errors are okay; even experienced programmers make many errors.  When you make an error, you just have to find the source of the problem, fix it, and move on.\n",
    "\n",
    "We have made an error in the next cell.  Uncomment the line below, run the cell and see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c077e3a-1bdc-4092-80c7-ff82493b8e6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(\"This line is missing something.\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a7ae90e-cf3d-44f0-8659-5ae4ce7fbbea",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f348589b7d23075245f5cf5df3cfe183",
     "grade": false,
     "grade_id": "cell-cbbe357c4fcbfb45",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "![ws1_error_image_python.png](images/ws1_error_image_python.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd675d23-7a4f-469b-90ce-f35b1eb7c10a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e4fb59f09fe931053806a828a6bce1fc",
     "grade": false,
     "grade_id": "cell-7f7efb59fbede5af",
     "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. If you see a cryptic message like this, you can often get by without deciphering it.  (Of course, if you're frustrated, ask a neighbor or a 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",
   "id": "cfed80f3-0d06-4d00-94bf-cd3bdeaba6fe",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0e45f3452f1839084cedbdd307e1a584",
     "grade": false,
     "grade_id": "cell-8e9a58a1f5336eec",
     "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",
   "id": "4c614525-6303-43e1-b71e-c0253c742ba4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ffc73d4b1974c2b9ac3424ac36e3b7eb",
     "grade": false,
     "grade_id": "cell-a7ef9e28949bda19",
     "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 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",
   "id": "9b7f97e2-1c10-4896-b47f-91f1d7c792a5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "82138b3ed9e1706fe6a187bf53162be4",
     "grade": false,
     "grade_id": "cell-475f9fb968597a57",
     "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": "markdown",
   "id": "fee70082-2651-48b9-84bf-4130ee50b58a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5ee0dfc5441977a51133d9c3f81ec2c0",
     "grade": false,
     "grade_id": "cell-cfb266d6f77e9a48",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Below are 2 videos that explain:\n",
    "\n",
    "1. [How to save your Jupyter notebook](https://www.youtube.com/watch?v=0aoLgBoAUSA) and,\n",
    "2. [How to answer a question in a Jupyter notebook assignment](https://www.youtube.com/watch?v=7j0WKhI3W4s).\n",
    "\n",
    "If they are not showing up below, uncomment the code in the cell below and run it. You can also click the links above to watch them directly on YouTube."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaffcb2f-c00c-47c5-878c-b50a27b992c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#from IPython.display import YouTubeVideo\n",
    "\n",
    "#YouTubeVideo(\"0aoLgBoAUSA\", width=854, height=480)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a2baecc-7c0c-457f-ad3c-0392a4251543",
   "metadata": {},
   "outputs": [],
   "source": [
    "#from IPython.display import YouTubeVideo\n",
    "\n",
    "# YouTubeVideo(\"7j0WKhI3W4s\", width=854, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "034de303-a57b-4b89-a15c-3297ca068f9e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "04959ad7f2f398117e45ffd555a16c2d",
     "grade": false,
     "grade_id": "cell-1c65ecccc4d7e214",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 2. Numbers\n",
    "Quantitative information arises everywhere in data science. In addition to representing commands to print out lines, our Python 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,
   "id": "831ed388-9ffa-4665-96fb-8861ab027bd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "3.2500"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a469f28",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7fcf051f0daa54bdee28d5eb6747f79a",
     "grade": false,
     "grade_id": "cell-face499c0dec1453",
     "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 will helpfully print the last output for you. So in the below cell, the last statement just evaluates to `4`, so it prints `4` (remember -- each line in a cell is a separate line of code!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad9cd7da-67cd-405b-9ce9-cb678864072b",
   "metadata": {},
   "outputs": [],
   "source": [
    "2\n",
    "3\n",
    "4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acb74ff6-fdcd-4541-ab76-ead35970a09d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8fb9235067412c6e64be74d6c6fa029e",
     "grade": false,
     "grade_id": "cell-4d62c33be470a93d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "If you want to print out results from earlier lines in the cell, you need to use the `print` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f153b4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2)\n",
    "print(3)\n",
    "print(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9d71451-ec95-47aa-81a9-332ebb27c460",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "563f281886e99f12faf0e2c3667584c0",
     "grade": false,
     "grade_id": "cell-5fea0d5af754c58d",
     "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,
   "id": "cbce8d82-dcee-4a5c-8267-5316fabcde0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "2.0 - 1.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d811ac4d-3181-45b7-b3fe-50ea6faefc59",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "66827e53abefdc3df845e02fac624a70",
     "grade": false,
     "grade_id": "cell-5654443ee25ba5cf",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Same with the cell below. Run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56b2fe4f-40c1-430d-b126-36605a67bd8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "2 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cca53c44-0d69-4ca2-852d-0ba434ede965",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3fb7a52db42a3aff67d2b3b22326f325",
     "grade": false,
     "grade_id": "cell-19aea892bc204b26",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Many basic arithmetic operations are built in to Python.  [This webpage](https://docs.python.org/3.9/library/operator.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",
   "id": "10e156f7-ea0d-4afc-a14e-bf5811811fbd",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "69b4f214e84cc2aadfc8184238ddf6b9",
     "grade": false,
     "grade_id": "cell-0d71d6720cd9a9f8",
     "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 Python, 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,
   "id": "853d8f95-2a68-4acb-8b79-35e117774604",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = 3 * 2 + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e963475e-3211-4b00-930d-7730808e9bb9",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7d9643aad84e0f43cf79623f1245ff72",
     "grade": false,
     "grade_id": "cell-8611f073ac17f64d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "When you run that cell, Python 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,
   "id": "647858da-7756-474d-a9bf-d8cfa3a9d36e",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9f8afcb-c04c-4d18-aea8-1d7c73113ae1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fc4979ab991f4561557c0095eb1308e8",
     "grade": false,
     "grade_id": "cell-aed2d4b98da49612",
     "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 Python 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",
   "id": "9fed7362-ef5e-43b8-90f3-64d487115266",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "78845b58d401157d3d70f99118bdfdf5",
     "grade": false,
     "grade_id": "cell-3c6ca4081bbf327a",
     "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,
   "id": "baec3a6e-583f-4d15-b510-2eb251bcd8b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "close_to_pi = 355 / 113\n",
    "close_to_pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ff03dd1-f013-4e5a-af88-12c5d8afd964",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3beed41b7586acf3bf09f965b89691ec",
     "grade": false,
     "grade_id": "cell-f932083064e1df68",
     "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,
   "id": "939bd12c-160e-4606-8d28-1c412a6cec99",
   "metadata": {},
   "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",
   "id": "2f437665-d480-439b-8a72-a8203207b7c4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "323eb297253aed6bd0991d12f1162b5c",
     "grade": false,
     "grade_id": "cell-587d029e8d438b16",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "When naming objects in Python there are some rules:\n",
    "1. Names in Python 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, 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. Instead, it is common to use an underscore character _ to replace each space.\n",
    "4. Names can't contain other special characters such as -, +, #, $, %, ^ since some characters have special roles in Python. Take # for example, this character specifies a comment within written code.\n",
    "\n",
    "Other than those rules, what you name something doesn't matter *to Python*.  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,
   "id": "c9625159-a0a7-4acc-887d-46840d5967b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 840\n",
    "b = 2 * a\n",
    "c = 12\n",
    "d = c * b\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27bb520b-9b82-4baf-965c-55328313fe9c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "98439f1723c462c79f17e285170c2690",
     "grade": false,
     "grade_id": "cell-e691d889f5ce968f",
     "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 Python 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",
   "id": "dfbf2566-65f5-47ec-b03a-19ba4801dd1e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "f4606b76e0ba5c581fed24af2998ae1b",
     "grade": false,
     "grade_id": "cell-e3b7b5c83bc8c306",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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,
   "id": "7e5655e9-537f-4130-93d2-b9e47f31c3d8",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "cd263c0331b624871910185d399dc699",
     "grade": false,
     "grade_id": "cell-fa740c28d48570e9",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\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",
   "id": "781556fb-5186-4a86-ade2-aef11d96cec0",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3e8933ab1228e6ffbe5340c96f1c2271",
     "grade": false,
     "grade_id": "cell-cc88a7ddee8e6310",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 3.2. Checking your code\n",
    "\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."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ff35925-fe84-4dcb-a436-d33ac900340c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c666955d1c6e34c6a9f14aad8ea1d953",
     "grade": false,
     "grade_id": "cell-ccb93669d1f0ac98",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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,
   "id": "54bb0ff3-cce1-4825-8fa7-2cf1ae0c9d2c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "00e9b5fccfbe078168bb1e8cf7e66cc6",
     "grade": true,
     "grade_id": "cell-7529fc41097cffcd",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(seconds_in_a_minute)).encode(\"utf-8\")+b\"f63740cc00b619a8\").hexdigest() == \"3477a35744ae914d16ea34e3ef0503296d1c60fa\", \"type of seconds_in_a_minute is not int. Please make sure it is int and not np.int64, etc. You can cast your value into an int using int()\"\n",
    "assert sha1(str(seconds_in_a_minute).encode(\"utf-8\")+b\"f63740cc00b619a8\").hexdigest() == \"00b3dd93aa1831461b8ead8a8420a12b56f5a557\", \"value of seconds_in_a_minute is not correct\"\n",
    "\n",
    "assert sha1(str(type(seconds_in_an_hour)).encode(\"utf-8\")+b\"accddfbdb25cbb86\").hexdigest() == \"9318290a0f9316c20adb638b9ca35ef30802ba13\", \"type of seconds_in_an_hour is not int. Please make sure it is int and not np.int64, etc. You can cast your value into an int using int()\"\n",
    "assert sha1(str(seconds_in_an_hour).encode(\"utf-8\")+b\"accddfbdb25cbb86\").hexdigest() == \"58b911d62083514b7978a0b375da4244c33afa17\", \"value of seconds_in_an_hour is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f00c5d6-a6c2-4a15-9281-234a688aebc4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0a0e67ad1ea88e6bf24d4e739c52e39c",
     "grade": false,
     "grade_id": "cell-8943f31756d8b856",
     "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,
   "id": "df82f185-55c1-4065-85fb-af9e764ca3f1",
   "metadata": {},
   "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",
   "id": "b68a7fb9-dafa-4294-a57c-85625d759a8b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b341bc2d476c76e6cf884ef036add648",
     "grade": false,
     "grade_id": "cell-0a43890382f989d4",
     "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",
   "id": "6f426631-b348-4b95-a2cc-c45ee0389c7d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b15f9d960aef2353a8bdbfa8887247f4",
     "grade": false,
     "grade_id": "cell-7f896db3cee2f9be",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 4. Calling Functions/Methods and Attributes\n",
    "\n",
    "The most common way to combine or manipulate values in Python is by calling functions or methods. Python comes with many built-in functions and methods that perform common operations. You can think of functions and methods as verbs that do things. And objects in Python like nouns, which are entities that exist.\n",
    "\n",
    "In the module, we explored examples of functions and methods such as `print`. Here, we'll demonstrate using another method `upper` that converts text to uppercase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1ac2477-8e91-40d0-b35b-b8f2db18aea9",
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting = \"Why, hello there!\".upper()\n",
    "greeting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e312aabe-7fb7-4668-b833-6b24ed40e071",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c6837645e1a877c9a64b01ce0c1bfa9b",
     "grade": false,
     "grade_id": "cell-8c55b6ac0edfa9f3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "> The `upper` method we used here is different from the functions we used previously (e.g. `print`). This method is called using the dot notation (`string.upper()`), because this method only works for a particular kind of object that they were designed to work for. Here the `upper` method was written to only work with string objects. `print` function, however, was written to work with many kinds of objects, therefore, we don't use the dot notation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32ee0fdd-a294-46da-8434-b27c99d76e37",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "57fa74ce84833d7d794d2b273edbbb07",
     "grade": false,
     "grade_id": "cell-6ccdcb3c0a754840",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 4.0** <br> {points: 1} \n",
    "\n",
    "Use the method `lower` 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,
   "id": "c74d88a1-edab-4d76-ad43-6fa16280d62d",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0c0cefe9587a3e36b1e6fcd56336547d",
     "grade": false,
     "grade_id": "cell-cd6693e3c0a44fac",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd1bb31b-7559-4adb-ae43-9624adf4bf98",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "912e560a7280173abcdd2c7de1b72a3b",
     "grade": true,
     "grade_id": "cell-2503df230be07a99",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(title)).encode(\"utf-8\")+b\"4a02a9fac26f187c\").hexdigest() == \"74e6c7cd604c219a09657981da8cac1adb50e305\", \"type of title is not str. title should be an str\"\n",
    "assert sha1(str(len(title)).encode(\"utf-8\")+b\"4a02a9fac26f187c\").hexdigest() == \"cc89838a600cb96ac4f19d08a922e8a008ddec11\", \"length of title is not correct\"\n",
    "assert sha1(str(title.lower()).encode(\"utf-8\")+b\"4a02a9fac26f187c\").hexdigest() == \"0ca4232ae884265060d5127e1d428043a1936534\", \"value of title is not correct\"\n",
    "assert sha1(str(title).encode(\"utf-8\")+b\"4a02a9fac26f187c\").hexdigest() == \"0ca4232ae884265060d5127e1d428043a1936534\", \"correct string value of title but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9740a3eb-5c4b-4310-9374-11735230d60f",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b158d894c38620024ea25814f13fa2e4",
     "grade": false,
     "grade_id": "cell-9a0d59a6ece59244",
     "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,
   "id": "4a4df2dc-4d41-4393-8389-6a0f6a161962",
   "metadata": {},
   "outputs": [],
   "source": [
    "biggest = max(2, 15, 4, 7)\n",
    "biggest"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4d21910-6c52-4fca-84d9-421adf6e48d8",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "d7f908cb7994b5930befc7355f5a3b94",
     "grade": false,
     "grade_id": "cell-3ef9de33479b6db4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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,
   "id": "77db1c66-dae2-477f-bff4-9369d984cdbf",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b17f944959af64675cb7b8231f6fab2a",
     "grade": false,
     "grade_id": "cell-7a31156e2f666d85",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "smallest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62e55951-e137-4c3e-b9d8-ec7e01120274",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d9886fd4ff0f8a0f1c92dbbadffc0a8e",
     "grade": true,
     "grade_id": "cell-b6d12a49c1b99ec4",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(smallest)).encode(\"utf-8\")+b\"4eea41f2186b858d\").hexdigest() == \"510a0d1322c553ff0a9812872f837985fab18af9\", \"type of smallest is not int. Please make sure it is int and not np.int64, etc. You can cast your value into an int using int()\"\n",
    "assert sha1(str(smallest).encode(\"utf-8\")+b\"4eea41f2186b858d\").hexdigest() == \"16fd87481587d2508b6cc8d19a93d6cebd8854b4\", \"value of smallest is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b821b4-42ac-4b2e-a093-76475353ea80",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b66eb16b58eeff76fee9247e7bfd60a1",
     "grade": false,
     "grade_id": "cell-c95f3d7b18991e17",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 5. Packages\n",
    "Python has many built-in functions, but we can also use functions that are stored within packages created by other Python users. We are going to use a package, called `pandas`, 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",
   "id": "a16d8cfc-9925-4aac-a753-6fe32b75ecbf",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fd7bcfeb5bd402de432b1a3066ca17e8",
     "grade": false,
     "grade_id": "cell-f5abb7dc64d74fb9",
     "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 `import` 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 Python code depends on). \n",
    "\n",
    "Here we also give `pandas` a nickname of `pd`, formally called an alias. This lets us refer to the pandas package more efficiently by just typing `pd` instead of `pandas`. Referring to packages with aliases is very common in Python and you will see us do this with many of the packages we use in this course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ae83b86-204b-43f9-96a4-59c9c159b85c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc7f57cc-3613-4b60-b6e9-1d9a969844ec",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ed83164c2802f3bab15d92629b176c06",
     "grade": false,
     "grade_id": "cell-93089aa3d8f4872d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 5.1** <br> {points: 1} \n",
    "\n",
    "Use the `import` function to load the `numpy` Python package as `np`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c496ffcf-c70f-4647-85d3-cb73da8d74af",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3dda3aedb06a4528ea2b14f0a0e0f4ee",
     "grade": false,
     "grade_id": "cell-a6558cfd60b4a110",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3440582-52c5-4c92-8380-a5213d2b5970",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "451209143807f0d714631aa2d76fa216",
     "grade": true,
     "grade_id": "cell-d3b2c1f9214bc7eb",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(('numpy' in sys.modules))).encode(\"utf-8\")+b\"bf63784a0c69bee8\").hexdigest() == \"a2e7805fff17c59d5a3468875322a2367d784d5c\", \"type of ('numpy' in sys.modules) is not bool. ('numpy' in sys.modules) should be a bool\"\n",
    "assert sha1(str(('numpy' in sys.modules)).encode(\"utf-8\")+b\"bf63784a0c69bee8\").hexdigest() == \"6bc7e0c230b8393a77b624b1c6e7539605237284\", \"boolean value of ('numpy' in sys.modules) is not correct\"\n",
    "\n",
    "assert sha1(str(type((np.__name__ == 'numpy'))).encode(\"utf-8\")+b\"cccdab030c8b29ca\").hexdigest() == \"202f26d6310e1f7ff6be7f4a604e3f2b552aa238\", \"type of (np.__name__ == 'numpy') is not bool. (np.__name__ == 'numpy') should be a bool\"\n",
    "assert sha1(str((np.__name__ == 'numpy')).encode(\"utf-8\")+b\"cccdab030c8b29ca\").hexdigest() == \"0f6ea0dcc7eac6bb48393e207c0c9f6eb1bf9b2f\", \"boolean value of (np.__name__ == 'numpy') is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8db99e3-9c5f-4739-be2d-cf6fdb8c5f45",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "60d44bbbe9c7aca8db0308cda838ee75",
     "grade": false,
     "grade_id": "cell-3c2442d7dec6c873",
     "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",
    "\n",
    "### 6.1. Help Files\n",
    "One of the most efficient places to look for help on how a function works is the Python documentation. Let’s say we wanted to pull up the documentation for the `read_csv` method in pandas. We can do this by typing the `?` character followed by the name we want more information about. Another way to view the documentation is to place the cursor on the name and then press `shift` + `tab`, or by clicking on the `Help` text\n",
    "in the menu bar at the top and then selecting `Show Contextual Help`, as described in detail in the textbook.\n",
    "\n",
    "Run the cell below to find out more about `.read_csv` function from the `pandas` package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "896557bc-4322-4ee7-965a-ea0ffc447a2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "?pd.read_csv"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49365d3a-8605-4d9d-af66-41360a5bafd6",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "6dcba30094149bf83d7870a1a16ffd13",
     "grade": false,
     "grade_id": "cell-0c413972e76e865d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "At the very top of the output, you will see the function itself and its arguments. Next is a description of what the function does. The bottom of the file specifies the package it is in (in this case, it is pandas). You’ll find that the most helpful sections on this page are “Parameters” and \"Examples\". \n",
    "\n",
    "- **Docstring** at the top 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",
    "- **Parameters** tells you the different parts that can be added to the function to make it more simple or more complicated. Often the “Parameters” sections doesn’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 **Returns** explains what to expect as an output.\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.\n",
    "- Sometimes there is a **See Also** section which may suggest similar functions that could be of use to the user."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fd05e61-c1ef-4932-8331-002607e1694c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "94f1acde735c65bc634cee22658bd907",
     "grade": false,
     "grade_id": "cell-f08d83c97769ca4a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Beyond the Python 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 Python 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 Python users."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eddd0790-bdb5-46ac-bf45-422ed0c97c82",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "92ad9b744d6511c1e3f0df60aef9676f",
     "grade": false,
     "grade_id": "cell-5aa77532e5f4e3b3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 6.1** Multiple Choice:\n",
    "<br> {points: 1}\n",
    "\n",
    "Use `?pd.read_csv` 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. `pd.read_csv` is useful for reading comma-separated values (csv) file into DataFrame.\n",
    "\n",
    "B. It can accept a possible parameter of `warnings=True`.\n",
    "\n",
    "C. The parameter delimiter is an alias for the parameter squeeze.\n",
    "\n",
    "D. `pd.read_csv` is perfect for reading a table of fixed-width formatted lines into DataFrame.\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,
   "id": "2ff21c32-8092-4dfc-9b41-71b52c21dcda",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "99eeae8cddde7957a545467e382ec908",
     "grade": false,
     "grade_id": "cell-c8862f329868d4e1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fb04377-034f-4832-9530-d39f08a7fee4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e5c04f8cfbf86113b892dea3335fb468",
     "grade": true,
     "grade_id": "cell-56242dcedf383fac",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer6_1)).encode(\"utf-8\")+b\"883c4754b8b7a3f9\").hexdigest() == \"6ef96ab387b289051f15fe12f1999a6b5b0e33c1\", \"type of answer6_1 is not str. answer6_1 should be an str\"\n",
    "assert sha1(str(len(answer6_1)).encode(\"utf-8\")+b\"883c4754b8b7a3f9\").hexdigest() == \"26d3690b8eb0adbf5db9718db7cd3dc913366a42\", \"length of answer6_1 is not correct\"\n",
    "assert sha1(str(answer6_1.lower()).encode(\"utf-8\")+b\"883c4754b8b7a3f9\").hexdigest() == \"989c06535122a1e83624b49f0a2867f063bfe178\", \"value of answer6_1 is not correct\"\n",
    "assert sha1(str(answer6_1).encode(\"utf-8\")+b\"883c4754b8b7a3f9\").hexdigest() == \"e3f0f0d669a2123352473067a8698a5f147ac10d\", \"correct string value of answer6_1 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e696dc9-380d-49c9-aa94-4091e98649a9",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "763ea4ec7d37bc0495c716e2dc309ba0",
     "grade": false,
     "grade_id": "cell-8a98e30b01245414",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 7. Pandas Functions \n",
    "\n",
    "Now that we have learned a little about Jupyter notebooks and Python, let's load a real dataset into Python and explore it. As we do this we will learn more about key data loading, wrangling and visualization functions in Python. \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),\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 male 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 Python.\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 Python:\n",
    "\n",
    "1. load the data set into Python\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 Python, 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",
   "id": "b64301e7-dfc1-4ba5-b97c-1fa24ace5014",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "929dfd2b7b013b76f916c40f5e63196b",
     "grade": false,
     "grade_id": "cell-c241117b798b2e54",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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,
   "id": "1966feaa-9631-43ea-bf6c-9e696f70e595",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "401a44022a7bc5f6de3b8a6c31c63ef6",
     "grade": false,
     "grade_id": "cell-b0dae9dbd2dfb1d9",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6880fb2d-6d23-4633-b7b6-6fbc1df30070",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4daeb264511461c4db903240ec5989c5",
     "grade": true,
     "grade_id": "cell-6985376adde63175",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer7_0_1)).encode(\"utf-8\")+b\"e95a1a9739dd8f02\").hexdigest() == \"f0fc578f4448ba4b0222b897ea62ead7b00c6aec\", \"type of answer7_0_1 is not str. answer7_0_1 should be an str\"\n",
    "assert sha1(str(len(answer7_0_1)).encode(\"utf-8\")+b\"e95a1a9739dd8f02\").hexdigest() == \"1a671eea6191956499dde85d140af122e1b98fbd\", \"length of answer7_0_1 is not correct\"\n",
    "assert sha1(str(answer7_0_1.lower()).encode(\"utf-8\")+b\"e95a1a9739dd8f02\").hexdigest() == \"79ed31bb1136ab2d71571ad4f818f241c821c7b1\", \"value of answer7_0_1 is not correct\"\n",
    "assert sha1(str(answer7_0_1).encode(\"utf-8\")+b\"e95a1a9739dd8f02\").hexdigest() == \"ff4e126d329172756e2d8da6cad72647d1e2f1d1\", \"correct string value of answer7_0_1 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c9db97a-77b8-4dfb-8556-bb2243b1875b",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "53b897cd359f6da8e66f29fb9c81528c",
     "grade": false,
     "grade_id": "cell-951560d04fe9eab3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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 either `True` or `False`.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45583221-7e6d-4113-a946-d14feb4d985e",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1ccde8a123f6b9d8f0e7f193b4bf2258",
     "grade": false,
     "grade_id": "cell-802959c354163ed6",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21f2c06a-d168-47ff-91db-a029627f3b66",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5459e559023df81cb00b2feffb1b94d4",
     "grade": true,
     "grade_id": "cell-403f625bd1bc2a0d",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer7_0_2)).encode(\"utf-8\")+b\"2836086c95a7907f\").hexdigest() == \"45eb09084073819c0a304d4790629bcb81670bf1\", \"type of answer7_0_2 is not bool. answer7_0_2 should be a bool\"\n",
    "assert sha1(str(answer7_0_2).encode(\"utf-8\")+b\"2836086c95a7907f\").hexdigest() == \"f1c2021a498614a2ff707056aa4717c9b7577b98\", \"boolean value of answer7_0_2 is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bcba324-d458-4a37-a0c8-04fe63d17e25",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "54a15dc290148327c4a3e6812a608298",
     "grade": false,
     "grade_id": "cell-1d89b4a972bd6d13",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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,
   "id": "72ce83db-fe80-4fe2-9e74-374eab47f171",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b24ca564378da7395298f937435187a6",
     "grade": false,
     "grade_id": "cell-22fc576a49c08552",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "541d6b36-dc75-4dbd-9080-78de3e1f6981",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b37ce78b5da51504e877a2e05a54ddd3",
     "grade": true,
     "grade_id": "cell-fd2aff2cf89d487b",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer7_0_3)).encode(\"utf-8\")+b\"69f0b8467af40818\").hexdigest() == \"e42b5befbba34eca5df749889358d48033300d10\", \"type of answer7_0_3 is not str. answer7_0_3 should be an str\"\n",
    "assert sha1(str(len(answer7_0_3)).encode(\"utf-8\")+b\"69f0b8467af40818\").hexdigest() == \"5f13f211f39f378913515d3f2c23cfc4b5a4f231\", \"length of answer7_0_3 is not correct\"\n",
    "assert sha1(str(answer7_0_3.lower()).encode(\"utf-8\")+b\"69f0b8467af40818\").hexdigest() == \"e4ed89359a4b65d72707d4dc013d3926f49f0ae0\", \"value of answer7_0_3 is not correct\"\n",
    "assert sha1(str(answer7_0_3).encode(\"utf-8\")+b\"69f0b8467af40818\").hexdigest() == \"af40803cebbf272c09f500c64833537c55585e2e\", \"correct string value of answer7_0_3 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "366f8e0b-224e-4a7a-9421-97fca497c7da",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "abaa848aab3689108ab3e082c81af2a2",
     "grade": false,
     "grade_id": "cell-36ecb26cfc323d40",
     "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 `pd.read_csv` function from the `pandas` package 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_py.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",
   "id": "4b906dac-69b6-4e9e-89ea-5eeac0de418e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1118995c9220b689f80909570fec951a",
     "grade": false,
     "grade_id": "cell-ea616e0e2e92f75b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 7.1.1** <br> {points: 1}\n",
    "\n",
    "Use the `pd.read_csv` function from `pandas` package to load the data from the `marathon_small.csv` file into Python. Save the data to an object called `marathon_small`. If you need additional help try `?pd.read_csv` and/or ask your neighbours or the Instructional team for help."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2782eea5-8ae4-41c8-a6a3-13a309aa8a83",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e1a5b102804dbfb9ac9f11d62ad44548",
     "grade": false,
     "grade_id": "cell-24c1180c6165d355",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# your code here\n",
    "raise NotImplementedError\n",
    "marathon_small"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a670e70-2ef9-4452-bf17-2cc523aab34e",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8e06626d1ef36c98b10c8de8c705a05c",
     "grade": true,
     "grade_id": "cell-240e3959187bfdd4",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(marathon_small)).encode(\"utf-8\")+b\"2b2cd8a8f7191b99\").hexdigest() == \"f70fd1cb365e7ef849abb68e07fcded0b8f51544\", \"type of type(marathon_small) is not correct\"\n",
    "\n",
    "assert sha1(str(type(marathon_small.shape)).encode(\"utf-8\")+b\"554d659718d61ba6\").hexdigest() == \"37d9acd1ce275b3115cb09c44b01b4912cb468b3\", \"type of marathon_small.shape is not tuple. marathon_small.shape should be a tuple\"\n",
    "assert sha1(str(len(marathon_small.shape)).encode(\"utf-8\")+b\"554d659718d61ba6\").hexdigest() == \"ac4aa5352c2f9f41b21ea9aacef2791c1ef4930d\", \"length of marathon_small.shape is not correct\"\n",
    "assert sha1(str(sorted(map(str, marathon_small.shape))).encode(\"utf-8\")+b\"554d659718d61ba6\").hexdigest() == \"991ba07577ed8a6d05d3e14f114b2fde519b585f\", \"values of marathon_small.shape are not correct\"\n",
    "assert sha1(str(marathon_small.shape).encode(\"utf-8\")+b\"554d659718d61ba6\").hexdigest() == \"b73f34a6fa67f28c61b09dac0b47d9fb7fe17ef4\", \"order of elements of marathon_small.shape is not correct\"\n",
    "\n",
    "assert sha1(str(type(sum(marathon_small.age))).encode(\"utf-8\")+b\"bd89c56249909613\").hexdigest() == \"899d284abdf751ed98eb68ba0d5e12fb6ceb3e4f\", \"type of sum(marathon_small.age) is not float. Please make sure it is float and not np.float64, etc. You can cast your value into a float using float()\"\n",
    "assert sha1(str(round(sum(marathon_small.age), 2)).encode(\"utf-8\")+b\"bd89c56249909613\").hexdigest() == \"a518ff73378773221c197311edd70ca545c82a36\", \"value of sum(marathon_small.age) is not correct (rounded to 2 decimal places)\"\n",
    "\n",
    "assert sha1(str(type(marathon_small.columns.values)).encode(\"utf-8\")+b\"2ced1db6836e8c39\").hexdigest() == \"fa85611df34b71d39b67d8094d4004a5a88e4bce\", \"type of marathon_small.columns.values is not correct\"\n",
    "assert sha1(str(marathon_small.columns.values).encode(\"utf-8\")+b\"2ced1db6836e8c39\").hexdigest() == \"15ff054fbb79b56c3d79c26a21acb8835e46f6b9\", \"value of marathon_small.columns.values is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0e73cc6-3316-41cd-ae22-b8febd6f83d1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3fdae3053cab0c7dcba8a15a4eac55c5",
     "grade": false,
     "grade_id": "cell-60fd4cfe0e82b04e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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 `pd.read_csv` to an object in Python?\n",
    "\n",
    "A. `data == pd.read_csv(\"example_file.csv\")`\n",
    "\n",
    "B. `data = pd.read_csv(\"example_file.csv\")`\n",
    "\n",
    "C. `data = pd.read_csv\"example_file.csv\"`\n",
    "\n",
    "D. `data = pd.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,
   "id": "4e7a5d21-b778-483b-a3ff-21d013acec07",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ec15ca5cef43b1ad9152b6705414d9f0",
     "grade": false,
     "grade_id": "cell-999b212edf7f7a12",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08499e29-e7e8-401c-886a-69875be124b7",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "76b49eb3d3e0a5cbc6efc2cd70b1758c",
     "grade": true,
     "grade_id": "cell-d67be1745e12b089",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer7_1_2)).encode(\"utf-8\")+b\"cc7f1e4f1b65d80f\").hexdigest() == \"e77058f13b23c94bbca2e0fa929e1398f7be3ea0\", \"type of answer7_1_2 is not str. answer7_1_2 should be an str\"\n",
    "assert sha1(str(len(answer7_1_2)).encode(\"utf-8\")+b\"cc7f1e4f1b65d80f\").hexdigest() == \"f38386450d509d040820b52b4378b3477460756f\", \"length of answer7_1_2 is not correct\"\n",
    "assert sha1(str(answer7_1_2.lower()).encode(\"utf-8\")+b\"cc7f1e4f1b65d80f\").hexdigest() == \"629a384db2e71cc7ca53221944d701682bf45c3b\", \"value of answer7_1_2 is not correct\"\n",
    "assert sha1(str(answer7_1_2).encode(\"utf-8\")+b\"cc7f1e4f1b65d80f\").hexdigest() == \"fc42f4a0c2d7677ca8a98724586c050e5c0c587a\", \"correct string value of answer7_1_2 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4312ae9-40ff-4f98-9cc9-bc20605e67b2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9775fe4272ae0992ec03d7ce6dda7d84",
     "grade": false,
     "grade_id": "cell-f95eaaffb33ed0bf",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 7.2. Data frames\n",
    "\n",
    "The functions from the `pandas` package give us a data frame and we can look at the structure of a data frame by simply writing its name to view the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "086cf277-802b-48d2-9b77-1966cc6d282f",
   "metadata": {},
   "outputs": [],
   "source": [
    "marathon_small"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64716746-28c6-4a25-91b9-3fb51bc86cb2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "65d06fd2806756ddc3e390cadbe27ae2",
     "grade": false,
     "grade_id": "cell-248613cbb9279a69",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "This returns the first 5 and last 5 rows of the data frame, and hides the middle rows with an ellipsis (`...`).\n",
    "\n",
    "By default, the first row of a data set is always the **header** that `pd.read_csv` uses to label the column. Therefore, the first row contains descriptive names while the rows below contain the actual data. The bolded column on the left without a header is called the index. For now you can think of this is the row numbers of the data frame.\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 `head` method to specify the number of rows you want to print."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec26cc2f-f3c9-4f13-9e47-82915eb270bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "marathon_small.head(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab2027c6-0894-41bc-a30c-0db8225322f0",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fba544e31ca9d8adeada12ab2cea0764",
     "grade": false,
     "grade_id": "cell-983b7872ae1629ea",
     "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",
   "id": "91346b5b-3932-45d6-8c16-d1f2d686826f",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "cab8a642dad5b128747a5d0276c71582",
     "grade": false,
     "grade_id": "cell-fff838ee8a3484b4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 7.2.1** <br> {points: 1}\n",
    "\n",
    "To know how many rows and columns there are, use the method `shape`. Assign the number of rows and columns to the object `rows_and_columns`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72412099-17b3-4234-8e3f-1717715dabc5",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "528a6d4de81d9bc716451a44b8a05224",
     "grade": false,
     "grade_id": "cell-1e9d7d4f354cfa7c",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "print(rows_and_columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23136baf-1ce6-431e-b285-dc721527a5f5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4589492470aaf3f225712f6843ae448c",
     "grade": true,
     "grade_id": "cell-f29f4e7f8262ef98",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(rows_and_columns)).encode(\"utf-8\")+b\"2643cd4864760c7b\").hexdigest() == \"b74ee382d9f6255ecfc54cfbedde786c480b1079\", \"type of rows_and_columns is not tuple. rows_and_columns should be a tuple\"\n",
    "assert sha1(str(len(rows_and_columns)).encode(\"utf-8\")+b\"2643cd4864760c7b\").hexdigest() == \"c805f45f38681b1a3af1c5161fc6cd0031e9ab81\", \"length of rows_and_columns is not correct\"\n",
    "assert sha1(str(sorted(map(str, rows_and_columns))).encode(\"utf-8\")+b\"2643cd4864760c7b\").hexdigest() == \"38f75643d15c8c19ea3b7ec5f567254da2148e8d\", \"values of rows_and_columns are not correct\"\n",
    "assert sha1(str(rows_and_columns).encode(\"utf-8\")+b\"2643cd4864760c7b\").hexdigest() == \"44f6b1a1968095d7eecf8e9646c902213bb581b7\", \"order of elements of rows_and_columns is not correct\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16cb4d24-35b3-4c13-8998-db585af14c25",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "001962dff7d4cac0b4ca5141b058a008",
     "grade": false,
     "grade_id": "cell-b71bc8f8e1c101d4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 7.3. Obtaining a subset of rows OR columns with `[]`\n",
    "\n",
    "One of the most common operations on a data frame is to *filter* its rows (observations) to keep only specific rows based on their entries in one or more columns. To do this we can use the `[]` operation on a `pandas` data frame.\n",
    "\n",
    "For example, if we had a data frame (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",
   "id": "43d352fc-373b-4c73-9712-5f7662782c93",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "dd7726596ba4714f41ff9877477a0f8e",
     "grade": false,
     "grade_id": "cell-9e632d9130c06aa0",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "<img src=\"images/ws1_filter_gen_py.png\" width=\"500\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74be1685-7ff0-419d-9e32-d4c295e250fe",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "11b85080bac5f5266b55b6214208b96e",
     "grade": false,
     "grade_id": "cell-5cc491398e4a2af8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 7.3.1** <br> {points: 1}\n",
    "\n",
    "Use the `[]` operation 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_rows`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9750f5fb-0cf1-4b75-9649-48c1bd8a88a5",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9c5dd0855ceac74c37191267a96fc5ee",
     "grade": false,
     "grade_id": "cell-f9d75cbfa165d08e",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "marathon_filtered_rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "959c0a1a-227c-4a4c-b20c-ec25d962d8c7",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8e41ab6d7f81817053962780fc539029",
     "grade": true,
     "grade_id": "cell-6f763cc77fbd7391",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(marathon_filtered_rows.shape)).encode(\"utf-8\")+b\"ccfe0e29d319f929\").hexdigest() == \"7b1acb62efc3615dde2f5348970ca1d488afe636\", \"type of marathon_filtered_rows.shape is not tuple. marathon_filtered_rows.shape should be a tuple\"\n",
    "assert sha1(str(len(marathon_filtered_rows.shape)).encode(\"utf-8\")+b\"ccfe0e29d319f929\").hexdigest() == \"407a5f3d08feb98b7ccfa547baa5ff069aa3f95e\", \"length of marathon_filtered_rows.shape is not correct\"\n",
    "assert sha1(str(sorted(map(str, marathon_filtered_rows.shape))).encode(\"utf-8\")+b\"ccfe0e29d319f929\").hexdigest() == \"d2d10516859e96b45e92bb81077ad68341ab9b07\", \"values of marathon_filtered_rows.shape are not correct\"\n",
    "assert sha1(str(marathon_filtered_rows.shape).encode(\"utf-8\")+b\"ccfe0e29d319f929\").hexdigest() == \"74f90c301eded60f5da492e4bffcb09cb7e7ea08\", \"order of elements of marathon_filtered_rows.shape is not correct\"\n",
    "\n",
    "assert sha1(str(type(marathon_filtered_rows.columns.values)).encode(\"utf-8\")+b\"2f3446aebf8f5c43\").hexdigest() == \"efd67b5e45f1626067ce6a30599317177513c90c\", \"type of marathon_filtered_rows.columns.values is not correct\"\n",
    "assert sha1(str(marathon_filtered_rows.columns.values).encode(\"utf-8\")+b\"2f3446aebf8f5c43\").hexdigest() == \"83d6285fd3cc1d9301fe6c84dbbb876ca59a5e1b\", \"value of marathon_filtered_rows.columns.values is not correct\"\n",
    "\n",
    "assert sha1(str(type(sum(marathon_filtered_rows.bmi))).encode(\"utf-8\")+b\"e87f6e5a1c41aaf4\").hexdigest() == \"b80e7deb6dd045be7170931e580b886466c66d47\", \"type of sum(marathon_filtered_rows.bmi) is not float. Please make sure it is float and not np.float64, etc. You can cast your value into a float using float()\"\n",
    "assert sha1(str(round(sum(marathon_filtered_rows.bmi), 2)).encode(\"utf-8\")+b\"e87f6e5a1c41aaf4\").hexdigest() == \"7636ed74b0e2fda6463f8ad2fbe032e33447258f\", \"value of sum(marathon_filtered_rows.bmi) is not correct (rounded to 2 decimal places)\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9dbb042-6062-4792-b48d-5bad8eac5a7c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b916d8563d43721aadafd8783dd93f1c",
     "grade": false,
     "grade_id": "cell-bf7d026515498f76",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 7.3.2** <br> {points: 1}\n",
    "\n",
    "The `[]` operation can also be used to subset columns via the syntax `data[['column1, 'column2']]`. Use the `[]` operation to subset your data frame `marathon_small` so it only contains the columns \"bmi\" and \"km10_time_seconds\". Assign your new filtered data frame to an object called `marathon_filtered_columns`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b4bdf0e-c5a7-4165-9711-50f411dfb9bd",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2d3efb7c5185204d05f72a5439be1dad",
     "grade": false,
     "grade_id": "cell-3951f3d869ab0b99",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "marathon_filtered_columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "061c3743-7f71-4915-a525-aea2032a0a39",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fcf7e04a81e1968596f6c3855b1c1478",
     "grade": true,
     "grade_id": "cell-b08895f4f287a649",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(marathon_filtered_columns.shape)).encode(\"utf-8\")+b\"885ff3263b7b102c\").hexdigest() == \"b5cc4cfcc9708c03d74daabdfc7199c66f68883a\", \"type of marathon_filtered_columns.shape is not tuple. marathon_filtered_columns.shape should be a tuple\"\n",
    "assert sha1(str(len(marathon_filtered_columns.shape)).encode(\"utf-8\")+b\"885ff3263b7b102c\").hexdigest() == \"c8749996a2013e1776cd445bcbc9120971edb9ae\", \"length of marathon_filtered_columns.shape is not correct\"\n",
    "assert sha1(str(sorted(map(str, marathon_filtered_columns.shape))).encode(\"utf-8\")+b\"885ff3263b7b102c\").hexdigest() == \"e446e84168ae47dac43734f3d8c9c56e44d478b3\", \"values of marathon_filtered_columns.shape are not correct\"\n",
    "assert sha1(str(marathon_filtered_columns.shape).encode(\"utf-8\")+b\"885ff3263b7b102c\").hexdigest() == \"36d3ef6afa6647512e54685a9c536cd4cd0a6882\", \"order of elements of marathon_filtered_columns.shape is not correct\"\n",
    "\n",
    "assert sha1(str(type(marathon_filtered_columns.columns.values)).encode(\"utf-8\")+b\"8bca4c14844dd0cb\").hexdigest() == \"0186e1a49efec1a01105f6d335bd27fe651db204\", \"type of marathon_filtered_columns.columns.values is not correct\"\n",
    "assert sha1(str(marathon_filtered_columns.columns.values).encode(\"utf-8\")+b\"8bca4c14844dd0cb\").hexdigest() == \"1fe973701c79090253e0f4ce0aa2143a6fff9737\", \"value of marathon_filtered_columns.columns.values is not correct\"\n",
    "\n",
    "assert sha1(str(type(sum(marathon_filtered_columns.bmi))).encode(\"utf-8\")+b\"b66e645315e45d96\").hexdigest() == \"1b52517e61df82f8e200a943aaa5b1f9e472806d\", \"type of sum(marathon_filtered_columns.bmi) is not float. Please make sure it is float and not np.float64, etc. You can cast your value into a float using float()\"\n",
    "assert sha1(str(round(sum(marathon_filtered_columns.bmi), 2)).encode(\"utf-8\")+b\"b66e645315e45d96\").hexdigest() == \"707b648d56cd513591f7907fc5c4f3f95c9722fb\", \"value of sum(marathon_filtered_columns.bmi) is not correct (rounded to 2 decimal places)\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "082e1774-3acd-4158-855a-16f1d5982cfe",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3b833e258c0397b5c057885904438230",
     "grade": false,
     "grade_id": "cell-bf95a8e094221faa",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 7.4. Obtaining a subset of rows AND columns with `loc[]`\n",
    "\n",
    "The `[]` operation is only used when you want to either filter rows **or** select columns;\n",
    "it cannot be used to do both operations at the same time. This is where `loc[]`\n",
    "comes in. When we use `loc` to select columns and rows by labels in a dataframe we always specify row condition first, and then the list of columns we want: `data.loc[data['column1'] == row_condition, ['column1', 'column2']]`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfe54e4f-4680-434b-8e24-aa089b9385dc",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8830187cf83d4b131b566168ed34b2cd",
     "grade": false,
     "grade_id": "cell-a92cdf20d8099781",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Question 7.4.1** <br> {points: 1}\n",
    "\n",
    "Use `loc` to keep only the male runners and the columns `bmi` and `km10_time_seconds` from `marathon_small`, i.e. perform both the steps from the previous two question in a single operation. Assign your new filtered data frame to an object called `marathon_male`. \n",
    "\n",
    "*Make sure you select `bmi` first and then `km10_time_seconds`*!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5cb8c0b-31e4-493c-a639-f899dac4e278",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "927a67897c9645081db1d3d680a9b875",
     "grade": false,
     "grade_id": "cell-15ab614529f2f742",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "marathon_male"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e00a0e28-93e8-4592-8309-f2ab513ee562",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d624198cdaea9780917ba669f7935d2d",
     "grade": true,
     "grade_id": "cell-f4c54ec7b8fb29b2",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(marathon_male.shape)).encode(\"utf-8\")+b\"995b372cd6a9652e\").hexdigest() == \"ddcaa4ea162bc1c6856add1a7684206df48377b4\", \"type of marathon_male.shape is not tuple. marathon_male.shape should be a tuple\"\n",
    "assert sha1(str(len(marathon_male.shape)).encode(\"utf-8\")+b\"995b372cd6a9652e\").hexdigest() == \"6a9c481398c02c958ec9ad58480f464cb3228dd0\", \"length of marathon_male.shape is not correct\"\n",
    "assert sha1(str(sorted(map(str, marathon_male.shape))).encode(\"utf-8\")+b\"995b372cd6a9652e\").hexdigest() == \"6029c487cc4e821374ae8a9e066324cb79c8806a\", \"values of marathon_male.shape are not correct\"\n",
    "assert sha1(str(marathon_male.shape).encode(\"utf-8\")+b\"995b372cd6a9652e\").hexdigest() == \"c177b9a27918d7b97ce4c2a02c775c944d50b326\", \"order of elements of marathon_male.shape is not correct\"\n",
    "\n",
    "assert sha1(str(type(sum(marathon_male.bmi))).encode(\"utf-8\")+b\"fb47962904e3324b\").hexdigest() == \"c8a9bd81406eb8244d2dbeef532b6e570b64462a\", \"type of sum(marathon_male.bmi) is not float. Please make sure it is float and not np.float64, etc. You can cast your value into a float using float()\"\n",
    "assert sha1(str(round(sum(marathon_male.bmi), 2)).encode(\"utf-8\")+b\"fb47962904e3324b\").hexdigest() == \"e022ff005b3a68415bc95635ded3d7a539736131\", \"value of sum(marathon_male.bmi) is not correct (rounded to 2 decimal places)\"\n",
    "\n",
    "assert sha1(str(type(sum(marathon_male.km10_time_seconds.dropna()))).encode(\"utf-8\")+b\"c2f26cbb762f44d9\").hexdigest() == \"3089c6acb1e136abd5f35f2180a64939504a684b\", \"type of sum(marathon_male.km10_time_seconds.dropna()) is not float. Please make sure it is float and not np.float64, etc. You can cast your value into a float using float()\"\n",
    "assert sha1(str(round(sum(marathon_male.km10_time_seconds.dropna()), 2)).encode(\"utf-8\")+b\"c2f26cbb762f44d9\").hexdigest() == \"2423600689c9bee17dbee418376f1cd82b6f67b9\", \"value of sum(marathon_male.km10_time_seconds.dropna()) is not correct (rounded to 2 decimal places)\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9498a4c6-0afa-43d8-bdba-a846d085f180",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8fbaebadf844eb9d91fe7438b7cab3b8",
     "grade": false,
     "grade_id": "cell-999e4ac260a20227",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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,
   "id": "e0c0f92b-684c-4799-aba1-d082a3bfdf66",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f775f1386e6c0ae78b40d8aac88ee7b0",
     "grade": false,
     "grade_id": "cell-fef84cfc236ffa82",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "457de5fa-c3f7-4795-99eb-e62b7a83b1d4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9369634afe70ae7b09dc2ffb46c29261",
     "grade": true,
     "grade_id": "cell-d22160a6a53e9237",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer7_4_2)).encode(\"utf-8\")+b\"d03d5ca0fa8c0296\").hexdigest() == \"ca7dc887975286b3c66f158821666ac1a1b3375a\", \"type of answer7_4_2 is not str. answer7_4_2 should be an str\"\n",
    "assert sha1(str(len(answer7_4_2)).encode(\"utf-8\")+b\"d03d5ca0fa8c0296\").hexdigest() == \"56e37365ae73aee65ef3833206676a3d93381a8a\", \"length of answer7_4_2 is not correct\"\n",
    "assert sha1(str(answer7_4_2.lower()).encode(\"utf-8\")+b\"d03d5ca0fa8c0296\").hexdigest() == \"031b261d8fe81a4f833e5e2fe80f9585af16c286\", \"value of answer7_4_2 is not correct\"\n",
    "assert sha1(str(answer7_4_2).encode(\"utf-8\")+b\"d03d5ca0fa8c0296\").hexdigest() == \"031b261d8fe81a4f833e5e2fe80f9585af16c286\", \"correct string value of answer7_4_2 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4283348-c67f-4fcd-8c2b-d1af48c25eb8",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7beaf798cf09a2119b213a22cb2af41e",
     "grade": false,
     "grade_id": "cell-da75a783fe460961",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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,
   "id": "d2a2c8a0-e158-4d07-bc7b-e0ee76c93e02",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "76c53b64a9fe5fb5a96b59bc82294c19",
     "grade": false,
     "grade_id": "cell-36f7cd2455f091e4",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "079d7ba1-5f13-421a-9840-5695ebee6c9a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "84d9b01c64137fc85a52c4321c7a1c38",
     "grade": true,
     "grade_id": "cell-377287ed889be893",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer7_4_3)).encode(\"utf-8\")+b\"2134eba6c7c6f7c4\").hexdigest() == \"9c38bd9d2ab481520b1802add29d9f0132d73cfe\", \"type of answer7_4_3 is not str. answer7_4_3 should be an str\"\n",
    "assert sha1(str(len(answer7_4_3)).encode(\"utf-8\")+b\"2134eba6c7c6f7c4\").hexdigest() == \"8eea4dad00dd232416584f1afc399f30c05c49c5\", \"length of answer7_4_3 is not correct\"\n",
    "assert sha1(str(answer7_4_3.lower()).encode(\"utf-8\")+b\"2134eba6c7c6f7c4\").hexdigest() == \"380f784a41f5a93be8ac54479631d4b94e9a9d64\", \"value of answer7_4_3 is not correct\"\n",
    "assert sha1(str(answer7_4_3).encode(\"utf-8\")+b\"2134eba6c7c6f7c4\").hexdigest() == \"380f784a41f5a93be8ac54479631d4b94e9a9d64\", \"correct string value of answer7_4_3 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85b8862c-79a7-4eb7-a745-25cabfdec8cb",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e86896353e1046da64a3db788f80774c",
     "grade": false,
     "grade_id": "cell-ef748fc407ce6033",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 7.5. Assign\n",
    "\n",
    "The method `assign` 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_py.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",
   "id": "85e2b0f5-b732-4050-bbe1-4094e9c42c2d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "81a843bbb22c4015675881ab62658284",
     "grade": false,
     "grade_id": "cell-0f02d49ecca99520",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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,
   "id": "80a1ee37-e318-4e7a-9f94-3dad134e16f1",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "2e969c361f98c71d750cff80bfd05f07",
     "grade": false,
     "grade_id": "cell-c2294c924457e667",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError\n",
    "marathon_minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66cd150f-64e9-47b3-aace-70844c197d86",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7cd33eaa4fa4101239317f69d999ac8d",
     "grade": true,
     "grade_id": "cell-0742b003e816693c",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(marathon_minutes.shape)).encode(\"utf-8\")+b\"f33f51462f3e9b3d\").hexdigest() == \"226430568940aa5712765309c164aebac4725224\", \"type of marathon_minutes.shape is not tuple. marathon_minutes.shape should be a tuple\"\n",
    "assert sha1(str(len(marathon_minutes.shape)).encode(\"utf-8\")+b\"f33f51462f3e9b3d\").hexdigest() == \"961e32ddef48c185c730e347ff99595854be30b7\", \"length of marathon_minutes.shape is not correct\"\n",
    "assert sha1(str(sorted(map(str, marathon_minutes.shape))).encode(\"utf-8\")+b\"f33f51462f3e9b3d\").hexdigest() == \"ec65178fb3d7e0378946ef77142f82e001841c74\", \"values of marathon_minutes.shape are not correct\"\n",
    "assert sha1(str(marathon_minutes.shape).encode(\"utf-8\")+b\"f33f51462f3e9b3d\").hexdigest() == \"44423375bcc4f3721665025f113ae3ac42efe791\", \"order of elements of marathon_minutes.shape is not correct\"\n",
    "\n",
    "assert sha1(str(type(sum(marathon_minutes.km10_time_seconds.dropna()))).encode(\"utf-8\")+b\"9a3ad9c2ab6a7f72\").hexdigest() == \"77a461477e41248f1fbf0aa19e547a824d2a17a5\", \"type of sum(marathon_minutes.km10_time_seconds.dropna()) is not float. Please make sure it is float and not np.float64, etc. You can cast your value into a float using float()\"\n",
    "assert sha1(str(round(sum(marathon_minutes.km10_time_seconds.dropna()), 2)).encode(\"utf-8\")+b\"9a3ad9c2ab6a7f72\").hexdigest() == \"a1401fed307a4e260a6fdb801cebb9919bb35114\", \"value of sum(marathon_minutes.km10_time_seconds.dropna()) is not correct (rounded to 2 decimal places)\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffedd25a-8e82-42e4-9e20-dd40631abb2d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "89818a89cf63872f344cc1c9f887cbee",
     "grade": false,
     "grade_id": "cell-b81ae2307202b486",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 7.5. Visualization\n",
    "`Altair` is powerful visualization package for Python. The fundamental object in `Altair` is the `Chart`, which takes a data frame as a single argument `alt.Chart(dataframe)`. With a chart object in hand, we can now specify how we would like the data to be visualized. We first indicate what kind of graphical mark we want to use to represent the data. We can set the mark attribute of the chart object using the the `Chart.mark_*` methods. The `encode` method builds a mapping between visual encoding channels (such as x, y, color, shape, size, etc.) and columns in the dataset.\n",
    "\n",
    "![ws1_ggplot_male_py.png](images/ws1_ggplot_male_py.png)\n",
    "\n",
    "Let's plot a scatterplot with the `bmi` on the x axis and `km10_time_minutes` on the y axis."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a58f0e39-f46c-47b8-bc63-0deace3b5b27",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "972ff59531d7ac89eef5c4a57283bc23",
     "grade": false,
     "grade_id": "cell-8a5d123874f35303",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Before we start plotting use `Altair`, we need to import the package. You'll see we give it the alias `alt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da1b0253-a102-4dc1-a613-f956100867ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "import altair as alt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c1dc3ae-3c88-470d-ad60-570afb6e3b41",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell to create a scatterplot of BMI against the time it took to run 10 km.\n",
    "\n",
    "plot = alt.Chart(marathon_minutes).mark_point().encode(\n",
    "    x=\"bmi\",\n",
    "    y=\"km10_time_minutes\"\n",
    ")\n",
    "plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33649ed4-1915-48e0-ae3e-57bffa0e48e4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c329a956cf8570e6786693298fab4732",
     "grade": false,
     "grade_id": "cell-96adbcf87f4c3870",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": 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,
   "id": "35ebf43b-881a-4c45-b949-92eb40fcd4ec",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "06938f52754bd1a353708c37bebd6a1c",
     "grade": false,
     "grade_id": "cell-864372beefdd3c33",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f3bd87a-3837-4008-8b69-5560b06404ba",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5dc7e3a45f6ca08d7b6cc95a618f9dd4",
     "grade": true,
     "grade_id": "cell-94ad6c2e2be7bd04",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "from hashlib import sha1\n",
    "assert sha1(str(type(answer7_6_1)).encode(\"utf-8\")+b\"9d289d4e70041648\").hexdigest() == \"d9e81fed8196db2066dff398e0ef18ad530fdc78\", \"type of answer7_6_1 is not str. answer7_6_1 should be an str\"\n",
    "assert sha1(str(len(answer7_6_1)).encode(\"utf-8\")+b\"9d289d4e70041648\").hexdigest() == \"0cc9f1d75dd257df7484035e46364a36f4274609\", \"length of answer7_6_1 is not correct\"\n",
    "assert sha1(str(answer7_6_1.lower()).encode(\"utf-8\")+b\"9d289d4e70041648\").hexdigest() == \"3180b5fba6c0e9f0047f32ceb637feb18e618f27\", \"value of answer7_6_1 is not correct\"\n",
    "assert sha1(str(answer7_6_1).encode(\"utf-8\")+b\"9d289d4e70041648\").hexdigest() == \"132c7966bf66bcaad443ffe2358d6d6a2119f9c2\", \"correct string value of answer7_6_1 but incorrect case of letters\"\n",
    "\n",
    "print('Success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f109d747-3674-4dc6-aa7e-37b844e411b0",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "001cc9fab61990fa7a56568835c57146",
     "grade": false,
     "grade_id": "cell-1858f04c6c64e648",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "The visualization code above barely scratches the surface of what `Altair`, and Python 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 specifying the title inside `alt.X()` or `alt.Y()` inside the encoder. You can also change the font size using the `configure_axis` method. Let’s do that for the scatterplot to make the labels easier to read."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36d315d9-f775-47cd-bc8b-3eb27962dcd6",
   "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",
    "marathon_plot = alt.Chart(marathon_minutes).mark_point().encode(\n",
    "    x=alt.X(\"bmi\").title(\"Body Mass Index\"),\n",
    "    y=alt.Y(\"km10_time_minutes\").title(\"10 km run time (minutes)\"),\n",
    ").configure_axis(\n",
    "    labelFontSize=12,\n",
    "    titleFontSize=12,\n",
    ")\n",
    "marathon_plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5fe9198-87e4-4d07-8f69-72359ae2cb6d",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b7063a8549ffac09acf96ebd8e830d67",
     "grade": false,
     "grade_id": "cell-bfbcb171b4f01e80",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Attributions\n",
    "- UC Berkley [Data 8 Public Materials](https://github.com/data-8/data8assets)\n",
    "- UBC [Key Capabilities in Data Science Programming in Python course](https://github.com/UBC-MDS/prog-python-data-science-students)"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "encoding": "# -*- coding: utf-8 -*-"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}