Week6_TimeSeriesData.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Week6_TimeSeriesData.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyP+ovQ+6ci3kTOLqH1eKBQP",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/cu-gwc-datascience/classes/blob/main/Week6_TimeSeriesData.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Week 6: Time Series Data Visualization**\n",
        "\n",
        "Girls Who Code @ Columbia\n",
        "\n",
        "Class 3: Intro to Data Science\n",
        "\n",
        "Week 6 curriculum by Marina Gemma (meg2203@columbia.edu). \n",
        "\n",
        "\n",
        "<img src=\"https://media4.giphy.com/media/LDaBbFGqUwjPq/giphy.gif?cid=ecf05e47wntryahj4oqkzftqc4iew3taxwp130s930ksev1j&rid=giphy.gif&ct=g\" width=\"300\" height=\"400\">\n",
        "\n",
        "\n",
        "## **Label and save your notebooks**\n",
        "\n",
        "1. Click on \"Copy to Drive\"\n",
        "\n",
        "2. Rename your notebook \"Week6_YourName.ipynb\"\n",
        "\n",
        "## Learning Objectives:\n",
        "\n",
        "* Learn about time series data\n",
        "* Track trends through time\n",
        "* Calculate daily, monthly, and annual averages\n",
        "* Find relationships between variables\n",
        "\n",
        "## What is time series data?\n",
        "\n",
        "Time series data is a type of data (say, temperature for example) that is collected in the same way over a period of time. \n",
        "\n",
        "Today we will first explore **temperature** measurements that were collected in Central Park over a **nine year period**, from January 1, 2013 to December 31, 2021.  \n",
        "\n",
        "As always, we will first import the packages we will use today:\n",
        "\n"
      ],
      "metadata": {
        "id": "3l-ITRPkRAxK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "#this sets a standard figure size\n",
        "plt.rcParams['figure.figsize'] = (10,5)"
      ],
      "metadata": {
        "id": "NCcD6D4CnZHh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, we will import our temperature data. We're calling it cpws because it comes from the **Central Park Weather Station (CPWS)**. However, you can name it something different if you'd like! \n",
        "\n",
        "Let's see what's in the dataset:"
      ],
      "metadata": {
        "id": "9HKgseF5oARj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws = pd.read_csv('https://raw.githubusercontent.com/cu-gwc-datascience/classes/main/data/CPWS_2013_2021_edited.csv', index_col=None)\n",
        "cpws.head(25)"
      ],
      "metadata": {
        "id": "itnYVftgQ7xx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Yikes! There are 104,652 rows of data! \n",
        "\n",
        "This is because ***hourly temperature measurements*** are reported in our dataset, along with ***daily and monthly averages*** for our nine year period (2013-2021). \n",
        "\n",
        "The first 23 lines report **hourly** temperature measurements for January 1, 2013. Note that the last displayed row (row 24) has a `REPORT_TYPE` of \"`SOD`\". This is the reported **daily** average for January 1, 2013. So the hourly measurements are followed by a daily average for each day, and each month of measurements is followed by a monthly average. \n",
        "\n",
        "Let's look at the first row of our pandas dataframe `cpws` using `.iloc[]`:"
      ],
      "metadata": {
        "id": "p-lZitzhpKvJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws.iloc[0]"
      ],
      "metadata": {
        "id": "YFjdemY2pKJo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We see that the value in the `DATE` column is reported as `2013-01-01T00:51:00`. This is a combination of the date of the measurement (January 1, 2013) and the time (00:51, or 12:51am). \n",
        "\n",
        "We can tell pandas to read the `DATE` column as a combination of date and time values using `pd.to_datetime()`:"
      ],
      "metadata": {
        "id": "qgUoaQMPw7uG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws['DATE'] = pd.to_datetime(cpws['DATE'])\n",
        "cpws['DATE']"
      ],
      "metadata": {
        "id": "_uW4pv_ZSb4I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice that the `dtype` at the bottom is now `dtype: datetime64[ns]`! \n",
        "\n",
        "Setting `cpws['DATE']` **equal** to `pd.to_datetime(cpws['DATE'])` tells pandas to replace the original `cpws['DATE']` column with the new, converted datetime column.\n",
        "\n",
        "We want to examine the temperature data, so let's find where that is located by printing the dataframe column names:"
      ],
      "metadata": {
        "id": "PKq-1jwxxsHL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws.columns"
      ],
      "metadata": {
        "id": "KyP3CxPPyGph"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "There's no column that just says ***temperature***. So what do we use? One way to find out is to explore the [documentation](https://www1.ncdc.noaa.gov/pub/data/cdo/documentation/LCD_documentation.pdf) of the dataset. Here, the various reported values in our dataset are explained in detail.\n",
        "\n",
        "Turns out `HourlyDryBulbTemperature`, `DailyAverageDryBulbTemperature`, or `MonthyMeanTemperature` are the values we are interested in -- they report the hourly, daily average, and monthly average temperatures, respectively. The *dry bulb temperature* is \"commonly used as the standard air temperature\", according to the National Oceanic and Atmospheric Administration (NOAA) [documentation](https://www1.ncdc.noaa.gov/pub/data/cdo/documentation/LCD_documentation.pdf). Due to the formatting of our data file, we have to run the code below to make sure that pandas reads these columns as numeric values:"
      ],
      "metadata": {
        "id": "i7YMAaZqyRYs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws['HourlyDryBulbTemperature'] = pd.to_numeric(cpws['HourlyDryBulbTemperature'], errors='coerce')\n",
        "cpws['MonthlyTotalSnowfall'] = pd.to_numeric(cpws['MonthlyTotalSnowfall'], errors='coerce')\n",
        "cpws['DailyPrecipitation'] = pd.to_numeric(cpws['DailyPrecipitation'], errors='coerce')\n",
        "cpws['DailySnowfall'] = pd.to_numeric(cpws['DailySnowfall'], errors='coerce')\n",
        "cpws['MonthlyTotalLiquidPrecipitation'] = pd.to_numeric(cpws['MonthlyTotalLiquidPrecipitation'], errors='coerce')"
      ],
      "metadata": {
        "id": "BdES7CnLSb7B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that we know our temperature data is good to go, we can try another quick and useful tool -- the pandas `.describe()` operation. This [generates descriptive statistics](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.describe.html) for your dataframe. It is a broad but informative look at the distribution of our dataset:"
      ],
      "metadata": {
        "id": "4hnVR1r9Yi9D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws.describe()"
      ],
      "metadata": {
        "id": "Q0gWOizmYU9T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To learn more about the values this returns, explore [here](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.describe.html). "
      ],
      "metadata": {
        "id": "d5Mf0DCvaLIR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's plot the temperature measurements for the full nine year period. We can plot the `DATE` column on the x-axis, and the `HourlyDryBulbTemperature` on the y-axis:"
      ],
      "metadata": {
        "id": "totJviJeFrrX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(cpws.DATE, cpws.HourlyDryBulbTemperature, marker='o')\n",
        "\n",
        "plt.xlabel('Date')\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Temperature, 2013-2021')"
      ],
      "metadata": {
        "id": "cD-5F8WkyPdd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the `plt.ylabel` line, we add `$^{\\circ}$` to display the **degree** symbol - our temperature units are reported in **degrees Fahrenheit**.\n",
        "\n",
        "There is a TON of data on this plot! Over 100,000 points. You can see the broad temperature cycle over the years - the temperatures get higher during the summer months, and lower during the winter months. Before we dive into long term trends, let's break this down and explore small scale trends first.\n",
        "\n",
        "Last week we used **filters** to create subsets of our dataframe. We will use filters again this week, but in a slightly different format. \n",
        "\n",
        "Let's say we want to examine temperatures in the month of January. First, we call our dataframe as we normally do:\n",
        "\n",
        "    cpws[]\n",
        "\n",
        "In order to **only** show data from the month of January, we need to tell the dataframe to display data where the `MONTH` column contains `January`: \n",
        "\n",
        "    (cpws['MONTH'] == 'January')\n",
        "\n",
        "We then combine our dataframe call `cpws[]` with the January data like so:\n",
        "\n",
        "    cpws[(cpws['MONTH'] == 'January')]\n",
        "\n",
        "See for yourself below:"
      ],
      "metadata": {
        "id": "rRXX0XSuf6E-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "january_temp = cpws[(cpws['MONTH'] == 'January')]\n",
        "january_temp"
      ],
      "metadata": {
        "id": "SFRDJfTj3lMM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This returns a dataframe subset that only contains rows where the `MONTH` column contains **January**.\n",
        "\n",
        "We can plot this January temperature data on the y-axis, and the `DATE` column on the x-axis:\n"
      ],
      "metadata": {
        "id": "koBBtHutoru6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(january_temp.DATE, january_temp.HourlyDryBulbTemperature)\n",
        "\n",
        "plt.xlabel('Date')\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Temperature, January 2013-2021')"
      ],
      "metadata": {
        "id": "wm0L8Bp1hAOH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "BUT, making and naming a filter each time we want to plot something can be tedious. With pandas, we can filter our dataset **directly** in the plotting command, like so:"
      ],
      "metadata": {
        "id": "aaRigrRgYEVB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(cpws[(cpws['MONTH'] == 'January')].DATE, cpws[(cpws['MONTH'] == 'January')].HourlyDryBulbTemperature)\n",
        "\n",
        "plt.xlabel('Date')\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Temperature, January 2013-2021')"
      ],
      "metadata": {
        "id": "g4RvUzrNYgFw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We just replaced `january_temp` with the filter criteria `cpws[(cpws['MONTH'] == 'January')]`, and made the exact same plot. \n",
        "\n",
        "Voila! We can filter and plot in the same line of code. \n",
        "\n",
        "\n",
        "## Using the DatetimeIndex\n",
        "\n",
        "\n",
        "An extremely powerful feature of pandas is the [DatetimeIndex](https://pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.html). Instead of using a numerical index like we have been (i.e. 0,1,2,3...), we can tell pandas to use our `DATE` column as the index of our `cpws` dataframe - allowing us to more easily search and plot our data based on the date it was collected. We do this by adding `.set_index('DATE')` to our `cpws` dataframe:"
      ],
      "metadata": {
        "id": "pKNXVBVkYldk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws = cpws.set_index('DATE')"
      ],
      "metadata": {
        "id": "2ILpdMZqblbO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Yay! Now we are using our date values as our index. You'll notice that the `DATE` column has moved from its original column position, and is now in the index column position:"
      ],
      "metadata": {
        "id": "8Z1PcxLAcFHx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws"
      ],
      "metadata": {
        "id": "LVgt2R5bcTm5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using the date as our index has simplified some things. \n",
        "\n",
        "We no longer need to plot the `DATE` column as our x-values. We can just add `.plot()` to the end of the dataframe column we are interested in (`HourlyDryBulbTemperature`) to create the same plots we made above:"
      ],
      "metadata": {
        "id": "7CABU2FGcfbK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws.HourlyDryBulbTemperature.plot()\n",
        "\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Temperature, 2013-2021')"
      ],
      "metadata": {
        "id": "R30uLNykdB5L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also add the filter directly to our plotting command as we did before:"
      ],
      "metadata": {
        "id": "txYMWk_KikXF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['MONTH'] == 'January')].HourlyDryBulbTemperature.plot()\n",
        "\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Temperature, January 2013-2021')"
      ],
      "metadata": {
        "id": "h6D1-EXhV0jo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Do you agree that using:\n",
        "\n",
        "    cpws[(cpws['MONTH'] == 'January')].HourlyDryBulbTemperature.plot()\n",
        "\n",
        "instead of:\n",
        "\n",
        "    plt.plot(cpws[(cpws['MONTH'] == 'January')].DATE, cpws[(cpws['MONTH'] == 'January')].HourlyDryBulbTemperature)\n",
        "\n",
        "is easier? Thanks pandas!\n",
        "\n",
        "We also don't have to include `plt.xlabel()` since pandas automatically labels the x-axis with the name of our index!\n",
        "\n",
        "In the plot directly above, we are able to see the variability in January temperatures across the 9 year time period, but it's hard to see the variability across the month of January *itself*. To better see this, we can plot the temperature against the days in January.\n",
        "\n",
        "We will want to isolate the temperatures for the month of January ***for each year*** -- we can do this by adding a second condition to our filter, which will filter by year, using the `&` sign:"
      ],
      "metadata": {
        "id": "vKiqFiVv1Ard"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2013)].HourlyDryBulbTemperature.plot()\n",
        "\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Temperature, January 2013')"
      ],
      "metadata": {
        "id": "7NcKuxj-kqRC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Be sure to keep `()` around each condition - the filter won't work without them!\n",
        "\n",
        "We can do the same for the January 2014 data, by switching the year we put into the filter:"
      ],
      "metadata": {
        "id": "DtbZV4Q6AcFk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2014)].HourlyDryBulbTemperature.plot()\n",
        "\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Temperature, January 2014')"
      ],
      "metadata": {
        "id": "PQyewI9iBJZU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "But when we try to plot the January 2013 and January 2014 temperature profiles together:"
      ],
      "metadata": {
        "id": "T9kaQ9xpBojj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2013)].HourlyDryBulbTemperature.plot()\n",
        "cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2014)].HourlyDryBulbTemperature.plot()\n",
        "\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Temperature, January 2013 and January 2014')"
      ],
      "metadata": {
        "id": "TNh9J4b6BoB6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "they won't plot on top of each other, since they are from different years.\n",
        "\n",
        "To compare the January 2013 and 2014 data on the same plot, we will need to parse the data a bit differently.\n",
        "\n",
        "## Using `.groupby()` in pandas\n",
        "\n",
        "We will do this by using the pandas [groupby](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html?highlight=groupby#pandas.DataFrame.groupby) `.groupby()` operation, which will group our data according to an index property.\n",
        "\n",
        "The notation is relatively straightforward:\n",
        "\n",
        "    cpws.groupby(cpws.index.dayofyear)\n",
        "\n",
        "where `dayofyear` can be replaced by the other attributes (month, year, etc.) listed [here](https://pandas.pydata.org/docs/reference/api/pandas.DatetimeIndex.html).\n",
        "\n",
        "When we want to use **filtered data**, we can put the filter directly in the `cpws` call and in the `.groupby()` command -- we just use `cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2013)]` instead of only `cpws` in both places:\n",
        "\n",
        "    cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2013)].groupby(cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2013)].index.dayofyear)\n",
        "\n",
        "\n",
        "Then we will add `.mean().HourlyDryBulbTemperature.plot()` to the end of the above code to create our plot -- adding the `.mean()` operation will give us the **average** of the hourly temperatures per day (equivalent to the **daily average**) since we grouped by `dayofyear`. Let's see how this looks below:"
      ],
      "metadata": {
        "id": "UYqllOEdQDu8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2013)].groupby(cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2013)].index.dayofyear).mean().HourlyDryBulbTemperature.plot(marker='o')\n",
        "\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Temperature, January 2013')"
      ],
      "metadata": {
        "id": "NNE9EIfNxsAE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here are the average daily temperatures for January 2013! We added `marker='o'` to the `.plot()` operation so that we could see where the point for each day falls on the plot. \n",
        "\n",
        "Let's add the average daily temperatures for January 2014 to the plot! We'll also add label names to the plot command, and add a legend so we can distinguish the two years from each other:"
      ],
      "metadata": {
        "id": "-9GbIOHAxz01"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2013)].groupby(cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2013)].index.dayofyear).mean().HourlyDryBulbTemperature.plot(marker='o', label='January 2013')\n",
        "cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2014)].groupby(cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == 2014)].index.dayofyear).mean().HourlyDryBulbTemperature.plot(marker='o', label='January 2014')\n",
        "\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Temperature, January 2013 and January 2014')\n",
        "plt.legend()"
      ],
      "metadata": {
        "id": "dvvZfIXBvrz1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Which year had the **coldest** daily average temperature in January? On approximately what day did this temperature occur?"
      ],
      "metadata": {
        "id": "XRTi9I4zxfNa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your answer here"
      ],
      "metadata": {
        "id": "h__pw_O_xeRL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now it's your turn -- compare the daily January temperature averages for 2020 and 2021. You will create almost the exact same plot as above, just changing the years to 2020 and 2021."
      ],
      "metadata": {
        "id": "AODIQx570y3x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your plot here"
      ],
      "metadata": {
        "id": "jkbUDayv1KUC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Which of these years had the **warmest** daily average temperature in January? On approximately what day did this occur?"
      ],
      "metadata": {
        "id": "my3LDJa61UtT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your answer here"
      ],
      "metadata": {
        "id": "Ta8M2Aar19Ax"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "What if we wanted to plot the January daily average temperatures for all 9 years? We *could* use one plotting command for each year, like we just did for the plots containing two years. OR we could use a `for` loop, and use one line of plotting code instead!\n",
        "\n",
        "The structure of our plotting command will be the same, but we will iterate over a list of the years we want to plot. We'll define the `years` list below:"
      ],
      "metadata": {
        "id": "9Zd7SaXH2UZ7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "years = [2013,2014,2015,2016,2017,2018,2019,2020,2021]"
      ],
      "metadata": {
        "id": "fA_BCSwQ3iRu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "And then create a `for` loop, replacing the individual year in `cpws['YEAR'] == 2013` with `cpws['YEAR'] == years[i]`:"
      ],
      "metadata": {
        "id": "C6Zo1qKW-kyJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(len(years)):\n",
        "  cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == years[i])].groupby(cpws[(cpws['MONTH'] == 'January') & (cpws['YEAR'] == years[i])].index.dayofyear).mean().HourlyDryBulbTemperature.plot(marker='o', label='January '+str(years[i]))\n",
        "\n",
        "plt.legend(bbox_to_anchor=(1.01, 1))\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.ylim([0,70])"
      ],
      "metadata": {
        "id": "JXH8z0hm3aGv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "And here we have the daily average January temperatures for all 9 years! We added `+str(years[i])` to the label name (`label='January '+str(years[i])`) in order to create individual entries for each of the 9 years in our legend, and added `bbox_to_anchor=(1.01, 1)` to our `plt.legend()` command to place the legend **outside** of the plot, since there isn't a lot of room left inside the plot. You can explore more ways to customize your plots [here](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.html).\n",
        "\n",
        "You'll notice this plot is hard to read though - the lines plot on top of each other, and it is hard to distinguish one year from another.\n",
        "\n",
        "This is *not* a great example of data visualization. There is a lot of variability and a lot of overlap, making the data difficult to interpret. We can say that January temperatures for 2013-2021 fall between ~10 and 60 degrees Fahrenheit, but's it's hard to pick out more detailed observations.\n",
        "\n",
        "Let's try visualizing **monthly averages** of the data instead, using `MonthlyMeanTemperature` in place of `HourlyDryBulbTemperature`. We'll start with 2013, as we did above. This time, we only need to filter for the year, 2013, and not the month, since we are interested in all the months. In the `.groupby()` operation, we change the index grouping from `dayofyear` to `month`: "
      ],
      "metadata": {
        "id": "GWezlpUm_vgM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['YEAR'] == 2013)].groupby(cpws[(cpws['YEAR'] == 2013)].index.month).mean().MonthlyMeanTemperature.plot(marker='o', label='2013')\n",
        "\n",
        "plt.xlabel('Month')\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Monthly Average Temperature, 2013')"
      ],
      "metadata": {
        "id": "3X9aA3KBEGbT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We added the x-label `plt.xlabel('Month')` back in to clarify that the 'DATE' being plotted was the month, not the number of days.\n",
        "\n",
        "We can then add 2014 to the plot, along with a legend:"
      ],
      "metadata": {
        "id": "ZaYjXh9hExYb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['YEAR'] == 2013)].groupby(cpws[(cpws['YEAR'] == 2013)].index.month).mean().MonthlyMeanTemperature.plot(marker='o', label='2013')\n",
        "cpws[(cpws['YEAR'] == 2014)].groupby(cpws[(cpws['YEAR'] == 2014)].index.month).mean().MonthlyMeanTemperature.plot(marker='o', label='2014')\n",
        "\n",
        "\n",
        "plt.legend()\n",
        "plt.xlabel('Month')\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Monthly Average Temperature, 2013 and 2014')"
      ],
      "metadata": {
        "id": "woLscbLvDeJS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Which year (2013 or 2014) was, on average, warmer? Was it a lot warmer, or just a little bit warmer?"
      ],
      "metadata": {
        "id": "I5Lnb8o2FVw2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your answer here"
      ],
      "metadata": {
        "id": "Dn_D8bgOFZ6r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, use a `for` loop to plot the monthly average temperatures for **each year** of our dataset. You can use the same for loop structure that we used above, but don't forget to edit the plotting command to plot the monthly averages instead of the daily averages. \n",
        "\n",
        "The list `years` is already defined, so you don't have to make a list this time. Don't forget to label your axes and add a title and a legend!"
      ],
      "metadata": {
        "id": "oiQDCPtIFcX2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your plot here"
      ],
      "metadata": {
        "id": "NW0JOk53Fwz0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "What observations, if any, can you make about the monthly average temperatures in this plot?"
      ],
      "metadata": {
        "id": "Xt6SJdDsG2io"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your answer here"
      ],
      "metadata": {
        "id": "kuHu7Y6bG720"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now let's explore the **yearly (or annual)** averages. \n",
        "\n",
        "First, we need to change the index grouping in the `.groupby()` operation from `month` to `year`.\n",
        "\n",
        "Since there is no column in our dataset that tells you the annual temperature averages, we will still plot `MonthlyMeanTemperature`. However, through grouping by year and taking the mean, we are actually calculating the annual average temperature! So problem solved:"
      ],
      "metadata": {
        "id": "fUwYcSarG9C8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['YEAR'] == 2013)].groupby(cpws[(cpws['YEAR'] == 2013)].index.year).mean().MonthlyMeanTemperature.plot(marker='o', label='2013')\n",
        "cpws[(cpws['YEAR'] == 2014)].groupby(cpws[(cpws['YEAR'] == 2014)].index.year).mean().MonthlyMeanTemperature.plot(marker='o', label='2014')\n",
        "\n",
        "\n",
        "plt.legend()\n",
        "plt.xlabel('Year')\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')\n",
        "plt.title('Central Park Yearly Average Temperature, 2013 and 2014')"
      ],
      "metadata": {
        "id": "CC6E2urnHVoo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Two points on a plot don't tell us much. To see broader trends, we need to plot **more** annual averages.\n",
        "\n",
        "Create a for loop below that plots the yearly averages for our dataset, using the list `years`. Again, you can use the same for loop structure for plotting as we did before, but update the plotting command with the appropriate index grouping and label. Don't forget your axis labels, legend, and title. "
      ],
      "metadata": {
        "id": "Wv73n5ueH3ye"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your plot here"
      ],
      "metadata": {
        "id": "czEOK2cMI4dH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. What year had the highest average temperature? \n",
        "2. What year had the lowest average temperature? \n",
        "3. Did any years have approximately the same average temperature?\n"
      ],
      "metadata": {
        "id": "N18qyJ6RI3oI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1. your answer here\n",
        "\n",
        "# 2. your answer here\n",
        "\n",
        "# 3. your answer here"
      ],
      "metadata": {
        "id": "66t02ytVKfM_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now try changing the limits of the y-axis using `plt.ylim()`. First, try `plt.ylim([50,60])`:"
      ],
      "metadata": {
        "id": "qsIIFS0oL_D8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# recreate your plot and add a ylimit"
      ],
      "metadata": {
        "id": "0N8tMb0LMlzA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now try with `plt.ylim([40,70])`. \n",
        "\n",
        "Does changing the displayed range of values on the y-axis change your answers to questions 1-3 above? Why or why not?"
      ],
      "metadata": {
        "id": "Z1W-AB2mMq5w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your reasoning here"
      ],
      "metadata": {
        "id": "hLffoQhkSKZe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We'll note here that there is a another way to create this plot *without* a for loop. Instead of using a for loop, we can **remove the filter** we used on `cpws` and plot the **annual averages** like this:"
      ],
      "metadata": {
        "id": "OXkwTkrpn_q9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws.groupby(cpws.index.year).mean().MonthlyMeanTemperature.plot(marker='o')\n",
        "\n",
        "plt.ylabel('Temperature ($^{\\circ}$F)')"
      ],
      "metadata": {
        "id": "JO4YZ_tVoNuX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Then why use a for loop when you can make this plot with one line of code?\n",
        "\n",
        "The main difference between this plot and your previous plot is that the points in this plot are all the **same color**. In the for loop, we were treating each year **individually**, which causes the for loop to assign each year its own color. However, if we don't filter our dataframe and instead plot all the years collectively, the plotting command treats them as the same series of data, and gives them all the same color.\n",
        "\n",
        "Going forward, which method you use is up to you -- both plots are telling you the same information, but color coding is a way to help distinguish your data if you wish.\n",
        "\n",
        "P.S. To remove the line between the points, add `linestyle=''` to the plotting command.\n",
        "\n",
        "Remember, we are plotting **averages** of these values over a period of time (i.e. day or month or year). Below we will plot **totals** for a period of time. "
      ],
      "metadata": {
        "id": "bsygFfUxoazQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## When it rains, it pours!\n",
        "\n",
        "Now let's explore something different. Our `cpws` dataset also contains measurements for **rainfall** and **snowfall**. The daily measurements are recorded as `DailyPrecipitation` and `DailySnowfall`. \n",
        "\n",
        "\n",
        "We can plot the `DailyPrecipitation` for 2020 like so:"
      ],
      "metadata": {
        "id": "g-ef5OU3RTpa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['YEAR'] == 2020)].DailyPrecipitation.plot(marker='o')"
      ],
      "metadata": {
        "id": "v5RT4jm7mE1w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "But remember that if we want to plot data from two different years on top of each other, we need to use `.groupby()`:"
      ],
      "metadata": {
        "id": "JLjTQH36nKUV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['YEAR'] == 2020)].groupby(cpws[(cpws['YEAR'] == 2020)].index.dayofyear).mean().DailyPrecipitation.plot(marker='o', label='2020')\n",
        "cpws[(cpws['YEAR'] == 2021)].groupby(cpws[(cpws['YEAR'] == 2021)].index.dayofyear).mean().DailyPrecipitation.plot(marker='o', label='2021')\n",
        "\n",
        "\n",
        "plt.legend()\n",
        "plt.xlabel('Day')\n",
        "plt.ylabel('Precipitation (inches)')\n",
        "plt.title('Central Park Precipitation, 2020 and 2021')"
      ],
      "metadata": {
        "id": "ijaRjpE5luB6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Which year (2020 or 2021) had the day with the **highest** precipitation?"
      ],
      "metadata": {
        "id": "6l_efP4HnilC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your answer here"
      ],
      "metadata": {
        "id": "Z4PXGVIMo5kI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You'll notice that many days on the above plot have a value of 0. This is because it doesn't rain everyday! With temperature, you will **always** have a measurement -- your record is continuous. However, with precipitation, you might have gaps in your data if there are days with no rain.\n",
        "\n",
        "Now, let's look at precipitation **by month** for 2020 and 2021. The column `MonthlyTotalLiquidPrecipitation` reports the **TOTAL** precipitation (in inches) that was recorded for that month:"
      ],
      "metadata": {
        "id": "SmGM7eIFnvYF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['YEAR'] == 2020)].groupby(cpws[(cpws['YEAR'] == 2020)].index.month).mean().MonthlyTotalLiquidPrecipitation.plot(marker='o', label='2020')\n",
        "cpws[(cpws['YEAR'] == 2021)].groupby(cpws[(cpws['YEAR'] == 2021)].index.month).mean().MonthlyTotalLiquidPrecipitation.plot(marker='o', label='2021')\n",
        "\n",
        "\n",
        "plt.legend()\n",
        "plt.xlabel('Month')\n",
        "plt.ylabel('Precipitation (inches)')\n",
        "plt.title('Central Park Monthly Total Liquid Precipitation, 2020 and 2021')"
      ],
      "metadata": {
        "id": "Uev6pAa2N24X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note the lack of a data point for March 2021. Either it didn't rain at all that month, or there is missing data! How might you go about finding out which it is?"
      ],
      "metadata": {
        "id": "iSY0styAVGbA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your answer here"
      ],
      "metadata": {
        "id": "4wDbx-stVGkR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Pick two other years, and plot the monthly precipitation totals:"
      ],
      "metadata": {
        "id": "YMyQEUWNm8KW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your plot here"
      ],
      "metadata": {
        "id": "sFqtCxtbxkwp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Which month had the most precipitation? Was it the same for each year?"
      ],
      "metadata": {
        "id": "c1lYjBx4xlNL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your answer here"
      ],
      "metadata": {
        "id": "jMq2D2o4xn9C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, let's plot the **total** yearly precipitation for all of the years in our dataset. We will use a for loop, but the syntax will be a bit different: \n",
        "\n",
        "* First, we will need to calculate the **SUM** of each year's `MonthlyTotalLiquidPrecipitation` values to get the total precipitation for that year. We will want to use a filter that filters the data by year `cpws[(cpws['YEAR'] == 2013)]`, and luckily, we can just add `.sum()` to the end of the filter and column name to calculate the total precipitation per year:\n",
        "\n",
        "      cpws[(cpws['YEAR'] == 2013)].MonthlyTotalLiquidPrecipitation.sum()\n",
        "\n",
        "* Instead of calling our pandas column and using `.plot()` at the end, we will use the `plt.plot()` command this time, and plot the list `years` as our x values.\n",
        "\n",
        "Combining all of this, we produce:"
      ],
      "metadata": {
        "id": "n1OwiZnHxucm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(len(years)):\n",
        "    plt.plot(years[i], cpws[(cpws['YEAR'] == years[i])].MonthlyTotalLiquidPrecipitation.sum(), marker='o', label=str(years[i]))\n",
        "\n",
        "plt.legend()\n",
        "plt.ylabel('Total Precipitation (inches)')"
      ],
      "metadata": {
        "id": "To0JupKnvabh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "1.   Which year had the most amount of rain?\n",
        "2.   Which year had the least amount of rain?\n",
        "\n"
      ],
      "metadata": {
        "id": "jwi9EX6O6A9u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1. your answer here\n",
        "\n",
        "# 2. your answer here"
      ],
      "metadata": {
        "id": "OcGjNb1E63xJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Your turn! Plot the total annual **snowfall** for each year in our dataset! Like we did above, do this using:\n",
        "\n",
        "* a for loop that iterates over the list `years`\n",
        "* the list `years` as your x-values\n",
        "* `MonthlyTotalSnowfall` instead of `MonthlyTotalLiquidPrecipitation` to calculate the total snowfall with `.sum()`\n",
        "* `plt.plot()` instead of `.plot()`\n",
        "* `label=str(years[i])` to label your points\n",
        "\n",
        "Don't forget to plot a title, legend, and axis labels!\n"
      ],
      "metadata": {
        "id": "utLpCtNa8e-d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your plot here"
      ],
      "metadata": {
        "id": "-Jj0e87T9rxD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "1.   Which year had the most snow?\n",
        "2.   Which year had the least snow?\n",
        "3.   What is the *range* of total snowfall for the 9 years you plotted?"
      ],
      "metadata": {
        "id": "s73dA33S-FYZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1. your answer here\n",
        "\n",
        "# 2. your answer here\n",
        "\n",
        "# 3. your answer here"
      ],
      "metadata": {
        "id": "ShAh-MLW-T6G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Is there any kind of relationship that exists between the yearly precipitation totals and the yearly snowfall total? Is one higher when the other is lower, or vice versa? If so, why might that be?"
      ],
      "metadata": {
        "id": "pGm3Hyd0ks5C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your answer here"
      ],
      "metadata": {
        "id": "oXhC7Eg-k7Lt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Plotting multiple measurements\n",
        "\n",
        "Now let's try plotting **different measurements** from the **same time**. We will plot the average of wind speed (`HourlyWindSpeed`) and the monthly total of liquid precipitation (`MonthlyTotalLiquidPrecipitation`) for each month in the year 2020: "
      ],
      "metadata": {
        "id": "pCfbvwIVk6dK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['YEAR'] == 2020)].groupby(cpws[(cpws['YEAR'] == 2020)].index.month).mean().HourlyWindSpeed.plot(marker='o', label='Wind Speed', c='g')\n",
        "cpws[(cpws['YEAR'] == 2020)].groupby(cpws[(cpws['YEAR'] == 2020)].index.month).mean().MonthlyTotalLiquidPrecipitation.plot(marker='o', label='Precipitation', c='b')\n",
        "\n",
        "plt.legend()\n",
        "plt.xlabel('Month')\n",
        "plt.ylabel('Wind Speed (mph) \\n Precipitation (inches)')"
      ],
      "metadata": {
        "id": "5mD84QeKhdxA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notice that we have **two labels** on the y-axis. This is because we are plotting two different measurements -- one is **wind speed**, measured in miles per hour (mph), and the other is **precipitation**, measured in inches. In the `plt.ylabel()`, adding `\\n` will create a new line in the label -- we included this so that `Wind Speed (mph)` and `Precipitation (inches)` aren't on the same line, making the y-label a bit easier to read. \n",
        "\n",
        "**Important Note**: We plotted the monthly **average** wind speed and the monthly **total** precipitation above. They are not *both* averages.\n",
        "\n",
        "Now you plot the monthly average of wind speed (`HourlyWindSpeed`) and the monthly total of liquid precipitation (`MonthlyTotalLiquidPrecipitation`) for each month in the year 2013:\n"
      ],
      "metadata": {
        "id": "iu6gC3-TlWjj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your plot here"
      ],
      "metadata": {
        "id": "QVumGE3kGe7d"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Do you notice a relationship between the monthly average wind speed and the monthly total precipitation? If yes, why do you think that is? If no, would you expect one? Why or why not?"
      ],
      "metadata": {
        "id": "UdtkM0WNGgWE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your answer here"
      ],
      "metadata": {
        "id": "wpdrZ5JFGtvk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now plot the monthly average wind speed for each **year**:\n",
        "\n",
        "\n",
        "\n",
        "*   Use a for loop that iterates over the list `years`\n",
        "*   Filter the data by year: `cpws[(cpws['YEAR'] == years[i])]`\n",
        "*   Use `.groupby()` to group the data by `month`\n",
        "* After using `.groupby()`, take the mean `.mean()` before calling your column `HourlyWindSpeed` in orer to calculate monthly average wind speed\n",
        "* Use `label=str(years[i])` in the plotting command, and don't forget to include a legend, title, and axis labels!\n",
        "\n"
      ],
      "metadata": {
        "id": "xGFe0kFDH1PC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your plot here"
      ],
      "metadata": {
        "id": "GY49Kvu1KwUh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Is there a trend that you see in wind speed over the course of each year?\n",
        "2. What months seem to always be the most windy?\n",
        "3. What months seem to be the least windy?"
      ],
      "metadata": {
        "id": "3k2Ko-uqKe59"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1. your answer here\n",
        "\n",
        "# 2. your answer here\n",
        "\n",
        "# 3. your answer here"
      ],
      "metadata": {
        "id": "_6HFvC_6Kr57"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Just for fun, let's plot the monthly temperature averages along with the monthly wind speed averages. These measurements have different ranges of y-values:"
      ],
      "metadata": {
        "id": "f6RB0_ErKuk1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cpws[(cpws['YEAR'] == 2013)].groupby(cpws[(cpws['YEAR'] == 2013)].index.month).mean().HourlyWindSpeed.plot(marker='o', label='Wind Speed', c='g')\n",
        "cpws[(cpws['YEAR'] == 2013)].groupby(cpws[(cpws['YEAR'] == 2013)].index.month).mean().HourlyDryBulbTemperature.plot(marker='o', label='Temperature', c='r')\n",
        "plt.legend()"
      ],
      "metadata": {
        "id": "i_-nmFpwLG8C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You barely see any variation in the wind speed values in green because the wind speed values span a much shorter and smaller range than the temperature values in red. \n",
        "\n",
        "We can fix this **visualization** problem by using a **secondary axis**. We can add a second y-axis on the right hand side of the plot that has a different range of y-values so that we can see variation in both temperature and wind speed more clearly. \n",
        "\n",
        "To add a secondary y axis, we'll need to learn some new syntax. We will need to name both data series that we are plotting, and distinguish temperature as the values that will be plotted on the secondary y-axis:\n",
        "\n",
        "    ax = cpws[(cpws['YEAR'] == 2013)].groupby(cpws[(cpws['YEAR'] == 2013)].index.month).mean().HourlyWindSpeed.plot(marker='o', label='Wind Speed', c='g')\n",
        "    ax2 = cpws[(cpws['YEAR'] == 2013)].groupby(cpws[(cpws['YEAR'] == 2013)].index.month).mean().HourlyDryBulbTemperature.plot(secondary_y=True, ax=ax, marker='o', label='Temperature', c='r')\n",
        "\n",
        "We named the wind speed plotting command \"`axis1`\" and the temperature plotting command \"`axis2`\". We also added `secondary_y=True` and  `ax=axis1,` to the temperature plotting command in order to assign it to the secondary y-axis. \n",
        "\n",
        "We can then label each y axis using individual commands, and make the text color match the data color if we wish:\n",
        "\n",
        "    axis1.set_ylabel('Wind Speed (mph)', c='g')\n",
        "    axis2.set_ylabel('Temperature ($^{\\circ}$F)', c='r')\n",
        "\n",
        "Combining all of these commands, we can create our plot\""
      ],
      "metadata": {
        "id": "305rSsdKLQwJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "axis1 = cpws[(cpws['YEAR'] == 2013)].groupby(cpws[(cpws['YEAR'] == 2013)].index.month).mean().HourlyWindSpeed.plot(marker='o', label='Wind Speed', c='g')\n",
        "axis2 = cpws[(cpws['YEAR'] == 2013)].groupby(cpws[(cpws['YEAR'] == 2013)].index.month).mean().HourlyDryBulbTemperature.plot(secondary_y=True, ax=axis1, marker='o', label='Temperature', c='r')\n",
        "\n",
        "axis1.set_ylabel('Wind Speed (mph)', c='g')\n",
        "axis2.set_ylabel('Temperature ($^{\\circ}$F)', c='r')"
      ],
      "metadata": {
        "id": "5l8SLy4fH_fL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. What relationship between **wind speed** and **temperature** do you observe?\n",
        "2. Would you have been able to see this relationship without the secondary y-axis? Why or why not?"
      ],
      "metadata": {
        "id": "c2Ia_XofNGYj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1. your answer here\n",
        "\n",
        "# 2. your answer here"
      ],
      "metadata": {
        "id": "FZnVzSoWNdVD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Finding values in your dataset\n",
        "\n",
        "Suppose you want to find the day with the highest total precipitation in our 9 years of data. Instead of plotting every day for every year and finding the largest value by looking at a plot, you can use `.nlargest()` to return the largest value in a given column:\n",
        "\n",
        "    cpws['column_name'].nlargest()\n",
        "\n",
        "The `.nlargest()` operation will automatically return the **5** largest values in that column. However, you can specify how many values you want it to return using `n=` inside the parentheses:\n",
        "\n",
        "    cpws['column_name'].nlargest(n=2)\n",
        "\n",
        "Where you can replace `2` with any number you'd like. You can use `.nsmallest()` in exactly the same way to find the smallest values in your column.\n",
        "\n",
        "If you **only** want the largest (maximum) value, you can use `.max()` instead:\n",
        "\n",
        "    cpws['column_name'].max()\n",
        "\n",
        "This just returns the maximum value. You can use `.min()` in exactly the same way to return the minimum value. \n",
        "\n",
        "To find the date that corresponds to your value, you can use:\n",
        "\n",
        "    cpws[cpws['column_name'] == value]\n",
        "\n",
        "Try finding the values listed below: "
      ],
      "metadata": {
        "id": "ntNTwDJAHfC2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# find the largest hourly temperature value (using HourlyDryBulbTemperature)\n"
      ],
      "metadata": {
        "id": "SQw0IaLdU1wL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#find the date that corresponds to the largest hourly temperature value\n"
      ],
      "metadata": {
        "id": "OYtv-YkRVqkg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# find the *smallest* hourly temperature value\n"
      ],
      "metadata": {
        "id": "dk_S9fi5XAUU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# find the date that corresponds to the *smallest* hourly temperature value\n"
      ],
      "metadata": {
        "id": "XRSJJI3pXH0f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#find the day that had the greatest total snowfall (using DailySnowfall)\n"
      ],
      "metadata": {
        "id": "lgZiYj53V3pX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#find the date that corresponds to the greatest total daily snowfall value\n"
      ],
      "metadata": {
        "id": "WpCZxJDQWVmm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# find the largest hourly wind gust (HourlyWindGustSpeed)\n"
      ],
      "metadata": {
        "id": "hsElmiT5WgeN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# find the date that corresponds to the largest hourly wind gust\n"
      ],
      "metadata": {
        "id": "VCDmneDgXdcP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Plotting the daily average temperature for your birthday!\n",
        "\n",
        "Our last exercise today will be plotting the **daily average temperature** for your birthday over the past nine years. We will use a `for` loop to create this plot!\n",
        "\n",
        "We will iterate over the list `years` (which lists all 9 years in the dataset) in our for loop.\n",
        "\n",
        "First, we will create a filter that filters out the month and day of your birthday. Your filter will have **3** conditions: \n",
        "\n",
        "      (cpws['YEAR'] == years[i]) \n",
        "      (cpws['MONTH'] == 'your bday month') #remember strings need to be in quotations!\n",
        "      (cpws['DAY'] == your bday)\n",
        "\n",
        "and when combined, will look like:\n",
        "\n",
        "    cpws[(cpws['YEAR'] == years[i]) & (cpws['MONTH'] == 'your bday month') & (cpws['DAY'] == your bday)]\n",
        "\n",
        "\n",
        "You do **not** need to use `.groupby()`. You'll want to plot the `DailyAverageDryBulbTemperature` for each year. Don't forget your axis labels and plot title!\n",
        "\n",
        "Extra credit: try assigning a colormap to your plot!"
      ],
      "metadata": {
        "id": "ACmt8u-0d-v7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# your birthday plot here"
      ],
      "metadata": {
        "id": "UHhlJrKKg98i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "1.   What year had the highest temperature on your birthday?\n",
        "2.   What year had the lowest temperature on your birthday?\n",
        "3.   Are there any years that had nearly the same temperature on your birthday?\n",
        "\n",
        "\n",
        "Try again with another date if you'd like!"
      ],
      "metadata": {
        "id": "IfHJyhvTg9Kp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# plot average temperature for another day of the year!"
      ],
      "metadata": {
        "id": "iQcVYLZCf8QV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# That's all for today!"
      ],
      "metadata": {
        "id": "6uVLOwVEstYA"
      }
    }
  ]
}