01-max-temperature-over-time-ncei.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "remove_cell"
    ]
   },
   "source": [
    "<div><img style=\"float: left; padding-right: 3em;\" src=\"https://avatars.githubusercontent.com/u/19476722\" width=\"150\" /><div/>\n",
    "\n",
    "# Earth Data Science Coding Challenge!\n",
    "Before we get started, make sure to read or review the guidelines below. These will help make sure that your code is **readable** and **reproducible**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "remove_cell"
    ]
   },
   "source": [
    "## Don't get **caught** by these Jupyter notebook gotchas\n",
    "\n",
    "<img src=\"https://miro.medium.com/v2/resize:fit:4800/format:webp/1*o0HleR7BSe8W-pTnmucqHA.jpeg\" width=300 style=\"padding: 1em; border-style: solid; border-color: grey;\" />\n",
    "\n",
    "  > *Image source: https://alaskausfws.medium.com/whats-big-and-brown-and-loves-salmon-e1803579ee36*\n",
    "\n",
    "These are the most common issues that will keep you from getting started and delay your code review:\n",
    "\n",
    "1. When you try to run some code on GitHub Codespaces, you may be prompted to select a **kernel**.\n",
    "   * The **kernel** refers to the version of Python you are using\n",
    "   * You should use the **base** kernel, which should be the default option. \n",
    "   * You can also use the `Select Kernel` menu in the upper right to select the **base** kernel\n",
    "2. Before you commit your work, make sure it runs **reproducibly** by clicking:\n",
    "   1. `Restart` (this button won't appear until you've run some code), then\n",
    "   2. `Run All`\n",
    "\n",
    "## Check your code to make sure it's clean and easy to read\n",
    "\n",
    "<img src=\"https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSO1w9WrbwbuMLN14IezH-iq2HEGwO3JDvmo5Y_hQIy7k-Xo2gZH-mP2GUIG6RFWL04X1k&usqp=CAU\" height=200 />\n",
    "\n",
    "* Format all cells prior to submitting (right click on your code).\n",
    "* Use expressive names for variables so you or the reader knows what they are. \n",
    "* Use comments to explain your code -- e.g. \n",
    "  ```python\n",
    "  # This is a comment, it starts with a hash sign\n",
    "  ```\n",
    "\n",
    "## Label and describe your plots\n",
    "\n",
    "![Source: https://xkcd.com/833](https://imgs.xkcd.com/comics/convincing.png)\n",
    "\n",
    "Make sure each plot has:\n",
    "  * A title that explains where and when the data are from\n",
    "  * x- and y- axis labels with **units** where appropriate\n",
    "  * A legend where appropriate\n",
    "\n",
    "\n",
    "## Icons: how to use this notebook\n",
    "We use the following icons to let you know when you need to change something to complete the challenge:\n",
    "  * &#128187; means you need to write or edit some code.\n",
    "  \n",
    "  * &#128214;  indicates recommended reading\n",
    "  \n",
    "  * &#9998; marks written responses to questions\n",
    "  \n",
    "  * &#127798; is an optional extra challenge\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "25d7e31869a5545f20c74410a8a5eb04",
     "grade": false,
     "grade_id": "instr-overview",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Climate change is affecting temperatures in locations around the country\n",
    "\n",
    "In this notebook, you will complete the following **five steps**:\n",
    "  1. **Set up** your analysis by importing any necessary libraries\n",
    "  2. **Download** data from the National Centers for Environmental Information (NCEI) about annual maximum daily average temperatures in Los Angeles, CA.\n",
    "  3. **Clean up** some artifacts in the dates of the downloaded data\n",
    "  4. **Convert** temperature values from units of Fahrenheit to Celcius\n",
    "  5. **Plot** the data and write a headline/takeaway for your plot\n",
    "  \n",
    "Once you have finished running this example analysis, you will **create your own notebook** in which to duplicate the analysis in a location of your choosing.\n",
    "  \n",
    "In many locations around the U.S. (and the world!), climate change is causing **increased temperatures**. You will be able to see these trends in the Los Angeles data, and likely in data from other locations as well.\n",
    "\n",
    "*But first...you have to set up this notebook for your analysis.*\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "aa89f8dcb8bff3cbe8ad459ace447127",
     "grade": false,
     "grade_id": "step-1",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## STEP 1: SET UP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "bda26707082a3b44ca10d30b0c293b7b",
     "grade": false,
     "grade_id": "instr-import",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Python is more powerful with **libraries**\n",
    "\n",
    "Because Python is **open source**, lots of different people and organizations can contribute (including you!). Many contributions are in the form of external &#128214; [**libraries**, also known as packages](https://www.earthdatascience.org/courses/intro-to-earth-data-science/python-code-fundamentals/use-python-packages/). Since they do not come with a standard Python download, &#128214; [external libraries need to be installed and **imported**](https://www.earthdatascience.org/courses/intro-to-earth-data-science/python-code-fundamentals/use-python-packages/). If you are using the `earth-analytics-python` environment on your computer or GitHub Codespaces, you should have everything you need installed.\n",
    "\n",
    "### There are excellent `Python` libraries for tabular data and plotting\n",
    "\n",
    "For this workflow, you will need the `pandas` library, which helps us to work with &#128214; [**tabular data** such as comma-separated value or csv files](https://www.earthdatascience.org/courses/intro-to-earth-data-science/file-formats/use-text-files/). You can think of tabular data as being like a **spreadsheet or database**. \n",
    "\n",
    "> It is customary to import the `pandas` library under its **alias** `pd`, to avoid taking up too much space when you use the library.\n",
    "\n",
    "You will also use the [`hvplot` library from Holoviz](https://hvplot.holoviz.org/index.html) to plot your results. There are many ways to plot in `Python`, but `hvplot` is both simple to use and powerful.\n",
    "\n",
    "### &#128187; YOUR TASK:\n",
    "\n",
    "Here is some code to import the pandas library, but **watch out! - there's a couple mistakes**:\n",
    "\n",
    "```python\n",
    "import hvplot.pands\n",
    "import pands as pd\n",
    "```\n",
    "\n",
    "Using the code above as a starting point, complete the following **two** steps:\n",
    "  1. [ ] Paste the code from above into the **code cell** below:\n",
    "  2. [ ] **Correct the typos** to properly import the pandas library under its **alias** pd as well as the hvplot pandas extension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fb229bd2fd9eb97b40ce396d41871b88",
     "grade": false,
     "grade_id": "code-import",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "862f854176d183ed8d30e9e4be500725",
     "grade": false,
     "grade_id": "test-instructions",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "The test cell below it will tell you if you completed the task successfully. **Do not try to modify the test cells.** If a test cell isn't working, check that you ran your code immediately before running the test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f77950e1404be256ea369f4c78beb2a8",
     "grade": true,
     "grade_id": "test-import",
     "locked": true,
     "points": 6,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# RUN THIS TEST CELL TO CHECK YOUR ANSWER - DO NOT MODIFY\n",
    "points = 0\n",
    "try:\n",
    "    pd.DataFrame()\n",
    "    points += 3\n",
    "    print('\\u2705 Great work! '\n",
    "          'You correctly imported the pandas library.')\n",
    "except:\n",
    "    print('\\u274C Oops - pandas was not imported correctly.')\n",
    "    \n",
    "try:\n",
    "    pd.DataFrame().hvplot\n",
    "    points += 3\n",
    "    print('\\u2705 Great work! '\n",
    "          'You correctly imported the hvplot.pandas library.')\n",
    "except:\n",
    "    print('\\u274C Oops - hvplot.pandas was not imported correctly.')\n",
    "    \n",
    "print('You earned {} of 5 points for importing libraries'.format(points))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "88fe19e501d963a96f0d547e13c55e66",
     "grade": false,
     "grade_id": "step-2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## STEP 2: DOWNLOAD DATA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "11cc8afdaec406fa4c623b2769ee1f07",
     "grade": false,
     "grade_id": "task-data-source",
     "locked": true,
     "points": 15,
     "schema_version": 3,
     "solution": false,
     "task": true
    }
   },
   "source": [
    "### Every day, petabytes of new Earth Observation data are made available online\n",
    "\n",
    "This workflow uses **annual mean temperature data** from the U.S. National Centers for Environmental Information (NCEI). &#128214; [Check out the NCEI Climate at a Glance website where you can search for more data like this](https://www.ncei.noaa.gov/access/monitoring/climate-at-a-glance/).\n",
    "\n",
    "![National Centers for Environmental Information Logo](https://www.nesdis.noaa.gov/s3/migrated/ncei_icon_550px.jpg)\n",
    "\n",
    "#### &#9998; YOUR TASK:\n",
    "  1. [ ] In the cell below, write a 2-3 sentence description of the data source. You should describe who takes the data, where they were taken, what the maximum temperature units are, and how they are collected.\n",
    "  2. [ ] Include a citation of the data (HINT: NCEI has a section for 'Citing this page', but you will have to select a particular dataset such as City > Time Series).\n",
    "  3. [ ] Add some **context** to your data analysis - research Los Angeles, CA and write a 2-3 sentence **site description**, including a relevant **image**. Don't forget to include the source of your image!\n",
    "  \n",
    "> HINT: double-click on the Markdown cells below to modify them.\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WRITE YOUR DATA DESCRIPTION HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WRITE YOUR DATA CITATION HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WRITE YOUR SITE DESCRIPTION HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "db3772b7bb18849a87ba131fbd5ff526",
     "grade": false,
     "grade_id": "instr-url",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Use a Uniform Resource Locator (URL) from NCEI to download data\n",
    "\n",
    "Here is a URL you can use to download the NCEI data you will need. Go ahead and &#128187; **copy and paste it into the code cell below**:\n",
    "\n",
    "```python\n",
    "'https://www.ncei.noaa.gov/access/monitoring/climate-at-a-glance/city/time-series/USW00023174/tavg/12/12/1945-2022.csv'\n",
    "```\n",
    "\n",
    "The URL is correct! However, we still have a problem - we can't get the URL back later on because it doesn't have a **name**. Right now, it just disappears into the void! \n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/c/cf/Black_hole_-_Messier_87.jpg/320px-Black_hole_-_Messier_87.jpg\" width=300 />\n",
    "\n",
    "> Image source: [Black Hole from Wikipedia](https://commons.wikimedia.org/wiki/File:Black_hole_-_Messier_87.jpg)\n",
    "\n",
    "#### &#128187; YOUR TASK:\n",
    "  1. [ ] Pick an **expressive name** for the URL value\n",
    "  2. [ ] **Reformat the URL** so that it adheres to the [79-character PEP-8 line limit](https://peps.python.org/pep-0008/#maximum-line-length)\n",
    "  3. [ ] **Call your url** (type out its name) at the end of the cell to test it.\n",
    "  \n",
    "#### &#128214; Read about [how to name a value](https://earthlab-education.github.io/Earth-Analytics-2023-01-Intro/intro-eds-textbook/04-python-fundamentals/01-get-started-python/python-fundamentals-02-variables.html) in Python in the textbook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bf696b5c36aa37fb45d584c8b3c5afed",
     "grade": false,
     "grade_id": "ans-url",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fde4af723ed22821448bae7bac784caf",
     "grade": true,
     "grade_id": "test-url",
     "locked": true,
     "points": 5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# RUN THIS TEST CELL TO CHECK YOUR ANSWER - DO NOT MODIFY\n",
    "url_ans = _\n",
    "points = 0\n",
    "\n",
    "import subprocess\n",
    "\n",
    "# Check the the answer was called for testing\n",
    "if isinstance(url_ans, str):\n",
    "    points += 1\n",
    "    print('\\u2705 Great work! You called a string.')\n",
    "else:\n",
    "    print('\\u274C Oops - make sure to call your url string for testing.')\n",
    "\n",
    "# Check the URL length to make sure it got copied correctly\n",
    "if len(url_ans) == 117:\n",
    "    points += 4\n",
    "    print('\\u2705 Great work! Your URL is the correct length.')\n",
    "else:\n",
    "    print('\\u274C Oops - your URL is not correct.')\n",
    "    \n",
    "# Subtract one point for any PEP-8 errors\n",
    "tmp_path = \"tmp.py\"\n",
    "with open(tmp_path, \"w\") as tmp_file:\n",
    "    tmp_file.write(In[-2])\n",
    "    \n",
    "ignore_flake8 = 'W292,F401,E302'\n",
    "flake8_out = subprocess.run(\n",
    "    ['flake8', \n",
    "     '--ignore', ignore_flake8, \n",
    "     '--import-order-style', 'edited',\n",
    "     '--count', \n",
    "     tmp_path],\n",
    "    stdout=subprocess.PIPE,\n",
    ").stdout.decode(\"ascii\")\n",
    "print('Formatting problems:')\n",
    "print(flake8_out)\n",
    "\n",
    "points -= int(flake8_out.splitlines()[-1])\n",
    "\n",
    "print('You earned {} of 5 points for naming the URL variable'.format(points))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ec4206b3990ea951419fe9388676dc97",
     "grade": false,
     "grade_id": "hint-whos",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "  > HINT: You can run the `%whos` **iPython magic command** to list all your variables (those are the ones that you can use at that moment). Many Python editors also have variable inspector features that will show you all your variables. Your url value will not be available until you save it to a variable. **Run the cell below and then check that your variable has been created**. Note that there will be other variables in the NameSpace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List all current variables\n",
    "%whos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "184b3eaad2ecdf3e46666b410fb22388",
     "grade": false,
     "grade_id": "task-download",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": true
    }
   },
   "source": [
    "### Use pandas to download the data\n",
    "\n",
    "The `pandas` library you imported can download data from the internet directly into a type of Python **object** called a `DataFrame`\n",
    "\n",
    "#### What do you notice about the code below? \n",
    "\n",
    "Here is some (not very clean) code to download NCEI data using `pandas`:\n",
    "\n",
    "```python\n",
    "dataframe = pd.read_csv(my_url, header=2, names=['col_1', 'col_2'])\n",
    "dataframe\n",
    "```\n",
    "\n",
    "#### &#9998; YOUR TASK: **Modify** the Markdown cell below and answer the following questions in a **numbered list**\n",
    "\n",
    "  1. [ ] What do you think the **parameters** of the `pd.read_csv()` function (e.g. `my_url`, `header`, `names`) are supposed to do? \n",
    "     \n",
    "     > HINT: &#128214; Check out [the pandas read_csv() documentation](https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html) for more info. You can also try changing putting the code in a code cell below running it with different values. See what happens!\n",
    "    \n",
    "  2. [ ] What are two things you could do to make this code more **expressive**?\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ANSWER THE QUESTIONS ABOUT PANDAS.READ_CSV() HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "79f788ca762c834a242bacbb8c61cd7b",
     "grade": false,
     "grade_id": "instr-download",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### &#128187; Let's fix some code! YOUR TASK:\n",
    "  1. [ ] Copy the example code from above into the cell below. Make any changes needed to get this code to run. Here's some hints:\n",
    "    > HINT: The my_url variable doesn't exist - you need to replace it with the variable name **you** chose.\n",
    "  2. [ ] Modify the value of the `header` parameter so that **only numeric data values** are included in each column.\n",
    "  3. [ ] Clean up the code by using **comments**, **expressive variable names**, **expressive column names**, and **PEP-8 compliant code**\n",
    "\n",
    "**Make sure to call your `DataFrame` by typing it's name as the last line of your code cell** Then, you will be able to run the test cell below and find out if your answer is correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7be14fe3d75462ced1803cf9a1a52cf2",
     "grade": false,
     "grade_id": "ans-download",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "26bfaa4eac2447772d1eb5baf57913c6",
     "grade": true,
     "grade_id": "tests-download",
     "locked": true,
     "points": 7,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# RUN THIS TEST CELL TO CHECK YOUR ANSWER - DO NOT MODIFY\n",
    "tmax_df_resp = _\n",
    "points = 0\n",
    "\n",
    "# Check that a DataFrame was called for testing\n",
    "if isinstance(tmax_df_resp, pd.DataFrame):\n",
    "    points += 1\n",
    "    print('\\u2705 Great work! You called a DataFrame.')\n",
    "else:\n",
    "    print('\\u274C Oops - make sure to call your DataFrame for testing.')\n",
    "    \n",
    "# Check that the DataFrame has the correct values\n",
    "summary = [round(val, 2) for val in tmax_df_resp.mean().values]\n",
    "if summary == [198362.0, 61.93]:\n",
    "    points += 6\n",
    "    print('\\u2705 Great work! You correctly downloaded data.')\n",
    "else:\n",
    "    print('\\u274C Oops - your data are not correct.')\n",
    "    \n",
    "# Subtract one point for any PEP-8 errors\n",
    "tmp_path = \"tmp.py\"\n",
    "with open(tmp_path, \"w\") as tmp_file:\n",
    "    tmp_file.write(In[-2])\n",
    "    \n",
    "ignore_flake8 = 'W292,F401,E302,F821'\n",
    "flake8_out = subprocess.run(\n",
    "    ['flake8', \n",
    "     '--ignore', ignore_flake8, \n",
    "     '--import-order-style', 'edited',\n",
    "     '--count', \n",
    "     tmp_path],\n",
    "    stdout=subprocess.PIPE,\n",
    ").stdout.decode(\"ascii\")\n",
    "print('Formatting problems:')\n",
    "print(flake8_out)\n",
    "points -= int(flake8_out.splitlines()[-1])\n",
    "\n",
    "print('You earned {} of 7 points for downloading data'.format(points))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9ef7160af3cb5318a0122d7e0a7a1462",
     "grade": false,
     "grade_id": "step-3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## STEP 3: CLEAN UP"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "aca04dfb60cbb0b97ca69ddab63a7359",
     "grade": false,
     "grade_id": "instr-format",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### It's very rare for downloaded data to be formatted *exactly* how we want when it is imported into `Python`\n",
    "\n",
    "First things first - Take a look at your data. Do you want to use it as is, or does it need to be modified?\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3b0f34249675257e008b8bb9ec38b818",
     "grade": false,
     "grade_id": "instr-get-year",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### &#128187; YOUR TASK:\n",
    "\n",
    "Below you will find some code that will extract the year from the funky yearmonth value NCEI gives us.\n",
    "\n",
    "```python\n",
    "dataframe.year = pd.to_datetime(dataframe.year, format='????').dt.year\n",
    "dataframe\n",
    "```\n",
    "\n",
    "> This code:\n",
    ">   1. Converts the yearmonth value to a `Datetime` type (`pd.to_datetime()`)\n",
    ">   2. Extracts only the year (`.dt.year`)\n",
    ">   3. Saves the year value back to the dataframe \"year\" column.\n",
    "\n",
    "Complete the following with the code above as a starting point:\n",
    "1. [ ] Copy and paste the code above into the code cell below\n",
    "2. [ ] Replace `dataframe` with the name of **your** dataframe whenever it appears.\n",
    "3. [ ] Replace `????` with the correct **date formatting string**. \n",
    " \n",
    " > HINT: Check out [the Python strftime documentation](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior).\n",
    " \n",
    "***\n",
    "\n",
    "### GOTCHA ALERT! We have a problem\n",
    "\n",
    "If you run this code twice, it will not run and you will get a `ValueError`. This happens because once you have extracted the **year only**, the format string you put in no longer applies.\n",
    "\n",
    "You don't have to do anything about this now - you can go `Run all above` (this is in the `Cell` menu in Jupyter Notebook) to reset. In the future, there are three approaches we recommend to address this sort of problem, depending on what you need your code to do:\n",
    "  1. Do not modify a `DataFrame` after it has been created - perform any changes you need in the **same cell** where you create the `DataFrame` using `pd.read_csv()`.\n",
    "  2. Create a new column when you want to compute new values (more on how to do this below).\n",
    "  3. Save a copy of the `DataFrame` using the `.copy()` method of `DataFrame`s and modify the copy (in the same cell).\n",
    "  \n",
    "When you reproduce this workflow in a location of your choosing, you can implement one of these strategies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8216c3b7b2db4fcf59b8811880bbbae9",
     "grade": false,
     "grade_id": "ans-get-year",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8f835df2084b2db925673bd928ba04ee",
     "grade": true,
     "grade_id": "tests-year",
     "locked": true,
     "points": 7,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# RUN THIS TEST CELL TO CHECK YOUR ANSWER - DO NOT MODIFY\n",
    "year_df_resp = _\n",
    "points = 0\n",
    "\n",
    "# Check that a DataFrame was called for testing\n",
    "if isinstance(year_df_resp, pd.DataFrame):\n",
    "    points += 1\n",
    "    print('\\u2705 Great work! You called a DataFrame.')\n",
    "else:\n",
    "    print('\\u274C Oops - make sure to call your DataFrame for testing.')\n",
    "    \n",
    "# Check that the DataFrame has the correct values\n",
    "summary = [round(val, 2) for val in year_df_resp.mean().values]\n",
    "if summary == [1983.5, 61.93]:\n",
    "    points += 6\n",
    "    print('\\u2705 Great work! You correctly extracted the year.')\n",
    "else:\n",
    "    print('\\u274C Oops - your data are not correct.')\n",
    "    \n",
    "# Subtract one point for any PEP-8 errors\n",
    "tmp_path = \"tmp.py\"\n",
    "with open(tmp_path, \"w\") as tmp_file:\n",
    "    tmp_file.write(In[-2])\n",
    "    \n",
    "ignore_flake8 = 'W292,F401,E302,F821'\n",
    "flake8_out = subprocess.run(\n",
    "    ['flake8', \n",
    "     '--ignore', ignore_flake8, \n",
    "     '--import-order-style', 'edited',\n",
    "     '--count', \n",
    "     tmp_path],\n",
    "    stdout=subprocess.PIPE,\n",
    ").stdout.decode(\"ascii\")\n",
    "print('Formatting problems:')\n",
    "print(flake8_out)\n",
    "points -= int(flake8_out.splitlines()[-1])\n",
    "\n",
    "print('You earned {} of 5 points for extracting the year'.format(points))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "47fe56ca846300a0f5367ca0430409c8",
     "grade": false,
     "grade_id": "step-4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## STEP 4: CONVERT UNITS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "20f9c33de17f79118a42784e81f336dc",
     "grade": false,
     "grade_id": "instr-units",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### For scientific applications, it is often useful to have values in metric units\n",
    "\n",
    "When you cited the data, you should have noted that temperature was in units of degrees Fahrenheit. Often we want data in metric units, because it makes important calculations (say, sensible heat from temperature) easier. Plus you don't want to be like the [NASA team who crashed a probe into Mars because different teams used different units](https://www.latimes.com/archives/la-xpm-1999-oct-01-mn-17288-story.html))!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "3c26c3284035eb4cef2fab8e04b63760",
     "grade": false,
     "grade_id": "instr-convert",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### &#128187; YOUR TASK:\n",
    "\n",
    "The code below converts the data to Celcius, using Python mathematical **operators**, like `+`, `-`, `*`, and `/`. Again, it's not well documented and doesn't follow [PEP-8 guidelines](https://peps.python.org/pep-0008/#other-recommendations), which has caused the author to miss an **important error**!\n",
    "\n",
    "```python\n",
    "dataframe['new_temperature']= dataframe['old_temperature']-32*5/9\n",
    "dataframe\n",
    "```\n",
    "\n",
    "Complete the following steps:\n",
    "1. [ ] Replace `dataframe` with the name of **your** `DataFrame`.\n",
    "2. [ ] Replace `'old_temperature'` with the column name **you** used; Replace `'new_temperature'` with an **expressive** column name. \n",
    "3. [ ] **THERE IS AN ERROR IN THE CONVERSION - Fix it!**\n",
    "  \n",
    "### Want an EXTRA CHALLENGE?\n",
    "Using the code below as a framework, write and apply a **function** that converts to Celcius. You should also rewrite this function name to be more expressive.\n",
    "  \n",
    "```python\n",
    "def convert(temperature):\n",
    "    \"\"\"Convert temperature to Celcius\"\"\"\n",
    "    return temperature # Put your equation in here\n",
    "\n",
    "dataframe['temp_c'] = dataframe['temp_f'].apply(convert)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8f96dd37422ad2aca9c12474b164b8b3",
     "grade": false,
     "grade_id": "ans-convert",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8854c917a311fca99c8e1508972174be",
     "grade": true,
     "grade_id": "tests-convert",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# RUN THIS TEST CELL TO CHECK YOUR ANSWER - DO NOT MODIFY\n",
    "celcius_df_resp = _\n",
    "points = 0\n",
    "\n",
    "# Check that a DataFrame was called for testing\n",
    "if isinstance(celcius_df_resp, pd.DataFrame):\n",
    "    points += 1\n",
    "    print('\\u2705 Great work! You called a DataFrame.')\n",
    "else:\n",
    "    print('\\u274C Oops - make sure to call your DataFrame for testing.')\n",
    "    \n",
    "# Check that the DataFrame has the correct values\n",
    "summary = [round(val, 2) for val in celcius_df_resp.mean().values]\n",
    "if summary == [1983.5, 61.93, 16.63]:\n",
    "    points += 9\n",
    "    print('\\u2705 Great work! You correctly converted units.')\n",
    "else:\n",
    "    print('\\u274C Oops - your data are not correct.')\n",
    "    \n",
    "# Subtract one point for any PEP-8 errors\n",
    "tmp_path = \"tmp.py\"\n",
    "with open(tmp_path, \"w\") as tmp_file:\n",
    "    tmp_file.write(In[-2])\n",
    "    \n",
    "ignore_flake8 = 'W292,F401,E302,F821'\n",
    "flake8_out = subprocess.run(\n",
    "    ['flake8', \n",
    "     '--ignore', ignore_flake8, \n",
    "     '--import-order-style', 'edited',\n",
    "     '--count', \n",
    "     tmp_path],\n",
    "    stdout=subprocess.PIPE,\n",
    ").stdout.decode(\"ascii\")\n",
    "print('Formatting problems:')\n",
    "print(flake8_out)\n",
    "points -= int(flake8_out.splitlines()[-1])\n",
    "\n",
    "print('You earned {} of 10 points for converting units'.format(points))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5a53678eee78f3d5b42e94d767c6a053",
     "grade": false,
     "grade_id": "step-5",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## STEP 5: PLOT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8359107d542bdc810c887e14de41f37a",
     "grade": false,
     "grade_id": "task-plot",
     "locked": true,
     "points": 15,
     "schema_version": 3,
     "solution": false,
     "task": true
    }
   },
   "source": [
    "### Plot the Maximum Annual Temperature in Los Angeles, CA, USA\n",
    "\n",
    "Present your work visually with a time-series plot of the maximum temperature values you downloaded.\n",
    "\n",
    "### &#128187; YOUR TASK:\n",
    "The code below is an attempt to plot the maximum temperature data with `Python`.\n",
    "\n",
    "```python\n",
    "dataframe.hvplot(x='col_1', y='col_2')\n",
    "```\n",
    "It's easy to plot in Python, but not quite this easy! You'll always need to add some instructions on labels and how you want your plot to look. Using the code above as a starting point, complete the following **four** steps:\n",
    "\n",
    "  1. [ ] Change `dataframe` to **your** `DataFrame` name.\n",
    "  2. [ ] Change `'col_1'` and `'col_2'` to **your** column names\n",
    "  3. [ ] Use the `title`, `ylabel`, and `xlabel` parameters to add key text to your plot.\n",
    "     > HINT: labels have to be a type in Python called a **string**. You can make a string by putting quotes around your label, just like the column names in the sample code.\n",
    "  4. [ ] &#9998; Write a **headline** for your plot in the markdown cell below\n",
    "    \n",
    "### &#x1F336; If you want an EXTRA CHALLENGE:\n",
    "Take a look at the [hvplot reference gallery](https://hvplot.holoviz.org/reference/index.html) to see if there's other changes you want to make to your plot. Some possibilities include:\n",
    "  * Remove the legend since there's only one data series\n",
    "  * Increase the figure size\n",
    "  * Increase the font size\n",
    "  * Change the colors\n",
    "  * Use a bar graph instead (usually we use lines for time series, but since this is annual it could go either way)\n",
    "  * [Add a trend line](https://holoviews.org/reference/elements/bokeh/Slope.html)\n",
    "  \n",
    "> HINT: to add a trend line, you will need to `import holoviews as hv` at the beginning of your notebook\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "YOUR PLOT HEADLINE HERE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c8bec3cfc289cc951f570aeb342200d5",
     "grade": false,
     "grade_id": "ans-plot",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "raise NotImplementedError()"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "ea-bootcamp-01-get-started-reproducible-science-svetlana-kurakina.ipynb",
   "provenance": []
  },
  "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.10.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": false,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}