Lesson_5_Pandas_DataFrame/Lesson5_pandas_DataFrame_Teacher.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/How-to-Learn-to-Code/python-class/blob/master/Lesson_5_Pandas_DataFrame/Lesson5_pandas_DataFrame_Teacher.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 5: Pandas as a dataframe API "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning objectives\n",
    "\n",
    "Students will gain a better understanding of how to use pandas for manipulating data frames\n",
    "\n",
    "Specific coding skills learned:\n",
    "- Subsetting data frames\n",
    "- Joining data frames together \n",
    "- Other useful pandas functions (incuding groupby, statistics, and conditional subsetting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install pandas \n", 
    "%pip install matplotlib \n",
    "%pip install numpy \n",
    "import pandas as pd \n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction\n",
    "\n",
    "In our last class, we discussed the basics of how to use pandas to read in our data. When we load in data from a CSV file with Pandas using a function such as reas_csv, we get a data structure known as a data frame. Basically, this is a two-dimensional table of rows and columns. \n",
    "\n",
    "This is useful in terms of allowing us to visualize our data, but most users will want to utilize the data for their own research purposes. Therefore, users will find it helpful to use pandas as an application programming interface (or API), which is basically a set of functions that allow users access to the features of the data. \n",
    "\n",
    "For this class, we are going to be using daily weather history data from multiple U.S. cities from July 2014 - June 2015 (downloaded from FiveThirtyEight's public repository of data found here: https://github.com/fivethirtyeight/data/tree/master/us-weather-history). \n",
    "\n",
    "The first set of data we are going to read in is from Philadelphia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://raw.githubusercontent.com/fivethirtyeight/data/master/us-weather-history/KPHL.csv\n",
    "philly_weather = pd.read_csv('KPHL.csv',index_col='date')\n",
    "philly_weather.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subsetting Data Frames\n",
    "\n",
    "The rows of this data frame represent each day during this period, and the columns represent the weather data that has been collected.\n",
    "\n",
    "As you can see, there are numerous types of data that has been collected, including the temperatures that occurred that day, what the average temperatures have been for that day over the years, the records for that day, and the amount of precipitation that occurred both on that day and on average for that day. \n",
    "\n",
    "##### Question 1: Let's say that you do not care about the temperature data, so most of these columns are not neccessary. How can you get the data you want to have? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "##### Answer: You can subset the data frame to only contain the columns you need"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In pandas, one of the ways you can select certain subsets of the data is to specify them by the row and/or column names.  \n",
    "\n",
    "To select a particular column (for example, the actual preciptation for each day) , you use square brackets [] along with the column name of the column of interest in quotation marks. Alternatively, this is known as \"slicing\", since you are taking a slice of the original data frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather[\"actual_precipitation\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to get both columns of precipitation data, we need to use double brackets, then within the brackets we list the columns of interest with a comma between them, as shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather[[\"actual_precipitation\",\"average_precipitation\",\"record_precipitation\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way of selecting these columns is to add to the end of our data frame object \".loc\" (which looks for the names of the columns by labels). Since our matrix is rows by columns, the \":\" symbol tells the computer that we want all of the rows, but only the columns with specific labels. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather.loc[:,[\"actual_precipitation\",\"average_precipitation\",\"record_precipitation\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Likewise, we can do the same for the rows, only placing the \":\" after the comma (in the columns position), and selecting the rows by label before the comma, as shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather.loc[[\"2014-7-1\"],:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather.loc[[\"2014-7-1\",\"2014-7-2\"],:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this is not too difficult if we only need a handful of rows and/or columns, this could become time-consuming if we want to get a series of rows and/or columns.\n",
    "\n",
    "##### Question 2: Instead of using the labels of the rows/columns, what is another attribute you can use to subset the data? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "##### Answer: You can use their numerical location (ex: the 1st row or 2nd column) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A little earlier in the lesson, we used \".loc\" to select rows and columns by their label. To do this by their index, we can instead use \".iloc\" to select the row and/or column index value(s). \n",
    "\n",
    "Given that the \"actual_precipitation\" and \"average_precipitation\" columns represent the 9th through 11th rows respectively, this is how we subset the data to obtain the values in these columns .\n",
    "\n",
    "(note: the first piece of code means \"select the data from the 9th column up to, but not including, the 12th column\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather.iloc[:,9:12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather.iloc[0:2,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the numbers are not in a sequence (ex: columns 0, 5, and 7), you can get the subset of the data like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather.iloc[:,[0,5,7]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Joining Data Frames \n",
    "\n",
    "Of course, we might not only be interested in the data from one city. Imagine that we want to do side-by-side comparisons of the average precipitation in Seattle vs. Philadelphia. \n",
    "\n",
    "Let's first read in the weather pattern data for Seattle as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://raw.githubusercontent.com/fivethirtyeight/data/master/us-weather-history/KSEA.csv\n",
    "seattle_weather = pd.read_csv('KSEA.csv',index_col='date')\n",
    "seattle_weather.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using what we learned earlier, we can subset our data to only look at the columns dealing with precipitation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather_precip = philly_weather.iloc[:,9:12]\n",
    "seattle_weather_precip = seattle_weather.iloc[:,9:12]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rather than having to flip between both data frames, we can instead combine them into one separate data frame using the function \"join\". \n",
    "\n",
    "There are four different ways that we can join our data, which we will go through below: \"left\", \"right\", \"inner\", and \"outer\" \n",
    "\n",
    "For the sake of an example, let us sort our data such that Philadelphia's precipitation data is sorted by the lowest to highest record precipitation, while Seattle's precipitation data is sorted from the highest to lowest record precipitation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather_precip_reordered = philly_weather_precip.sort_values(by=[\"record_precipitation\"], axis=0, ascending=True)\n",
    "philly_weather_precip_reordered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seattle_weather_precip_reordered = seattle_weather_precip.sort_values(by=[\"record_precipitation\"], axis=0, ascending=False)\n",
    "seattle_weather_precip_reordered"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A left join indicates that we preserve the order of the data frame is getting another data frame joined to it (in this case, the Philadelphia precipitation data). Since the suffix names are the same for both dataframes, we use lsuffix and rsuffix to specify which columns came from which dataframe. \n",
    "\n",
    "(Note: 'left' is the default setting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather_precip_reordered.join(seattle_weather_precip_reordered, how ='left', lsuffix = '_philly', rsuffix = '_seattle')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Likewise, a right join indicates that we preserve the order of the data frame that is being joined to the first data frame (in this case, the Seattle precipitation data)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather_precip_reordered.join(seattle_weather_precip_reordered, how ='right', lsuffix = '_philly', rsuffix = '_seattle')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to order the dates lexographically, we can change the how parameter to 'outer' (or the union of the datasets). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather_precip_reordered.join(seattle_weather_precip_reordered, how ='outer', lsuffix = '_philly', rsuffix = '_seattle')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we combine these datasets together, we can easily compare data from both data frames, for example plotting the record precipitation in Seattle vs. Philadelphia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_precipitation = philly_weather_precip.join(seattle_weather_precip,lsuffix = '_philly', rsuffix = '_seattle')\n",
    "ax = plt.gca()\n",
    "all_precipitation.plot(kind='line',y='record_precipitation_philly',ax=ax, color = 'purple',figsize=(12,5))\n",
    "all_precipitation.plot(kind='line',y='record_precipitation_seattle',ax=ax, color = 'green',figsize=(12,5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us pretend that we want to add information about each month (stored in the months object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "months = pd.Series(['July', 'August','September','October','November','December','January','February','March','April','May','June'])\n",
    "months = months.repeat([31,31,30,31,30,31,31,28,31,30,31,30])\n",
    "months = pd.DataFrame(months, columns = ['months'])\n",
    "months.index = all_precipitation.index\n",
    "months.index.name = 'date'\n",
    "months"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us say that in addition to the rainfall data, we also started to collect information about the average dewpoint on each day for the first three months in Philadelphia. However, due to statewide budget cuts scientists could not afford to gather data for the rest of the year."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dewpoint = np.random.randint(40,70,size=92)\n",
    "dewpoint = pd.DataFrame(dewpoint, columns=['dewpoint'])\n",
    "dewpoint.index = all_precipitation.index[0:92]\n",
    "dewpoint.index.name = 'date'\n",
    "dewpoint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As done previously, we can join the datasets together, but you will notice below that all of the dates where there was no dewpoint recorded are labeled 'NaN' (\"Not a number\", or undefined, data points)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather_precip.join(dewpoint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if you only want to keep the values where dewpoints are recorded? To do this, you can use join with the how parameter set to 'inner' (or intersection of the data), as shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather_precip.join(dewpoint, how='inner')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other useful pandas functions: conditional subsetting \n",
    "\n",
    "There are other ways to subset datasets by their index or their rownames/colnames. \n",
    "\n",
    "Let us say that you are only looking for days where the max temperature was greater than 90. How would we be able to get only those rows?\n",
    "\n",
    "To do this, we can do something called conditional subsetting.\n",
    "\n",
    "Remember in lesson 1 when we learned about comparisons, such as \"greater than\" ( > ), \"lesser than\" ( < ),  \"equals\" (==)? We can subset our data this way as well. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To pick the rows where the max temperature was greater than 90, we can subset the data as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather[philly_weather[\"actual_max_temp\"] > 90]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another example, what if we wanted to get all the days where it did not rain?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather[philly_weather[\"actual_precipitation\"] == 0.00]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we want to omit years where the high occurred that year? (Hint: remember the boolean operators AND (&) and OR (|)\n",
    "\n",
    "Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather[(philly_weather[\"record_max_temp_year\"] != 2014) & (philly_weather[\"record_max_temp_year\"] != 2015)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other useful pandas functions: groupby\n",
    "\n",
    "Let us go back to to the all_precip_wmonths object, when we added information about which month each day was in for the combined Philly and Seattle precipitation data. One neat thing we can do is to group data based on certain column values (such as months), as shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_precip_wmonths.groupby([\"months\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do functions such as mean, min, and max for each month, rather than every day. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_precip_wmonths.groupby([\"months\"]).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_precip_wmonths.groupby([\"months\"]).min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_precip_wmonths.groupby(['months']).max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember when we plotted the record precipitation in Philadelphia vs. Seattle? What if we instead plotted the mean month-to-month instead of daily?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_months_precip = all_precip_wmonths.groupby([\"months\"]).mean()\n",
    "ax2 = plt.gca()\n",
    "mean_months_precip.plot(kind='line',y='record_precipitation_philly',ax=ax2, color = 'purple',figsize=(12,5))\n",
    "mean_months_precip.plot(kind='line',y='record_precipitation_seattle',ax=ax2, color = 'green',figsize=(12,5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From this graph, we can see that months where the record precipitation was on average the highest in Philadelphia (such as August and July) are the lowest precipitation times in Seattle!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other useful pandas functions: statistics\n",
    "\n",
    "Lastly, we can perform statistics on our data as a whole. We have already gone through how certain mathematical functions such as min, max, or mean can be calculated on different groups, but this can also be done to columns of the data frame as well. \n",
    "\n",
    "For example, we can get the mean value of the actual precipitation in Seattle and Philadelphia, as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_precip_wmonths[\"actual_precipitation_seattle\"].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_precip_wmonths[\"actual_precipitation_philly\"].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, on average the daily precipitation in Philadelphia is only 0.02 inches greater than Seattle. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you wanted to look at both at the same time, we follow the same rules that we did in label-based subsetting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_precip_wmonths[[\"actual_precipitation_seattle\",\"actual_precipitation_philly\"]].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, if you wanted to look at multiple statistics at once, you can call the function 'describe', as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_precip_wmonths[[\"actual_precipitation_seattle\",\"actual_precipitation_philly\"]].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## In-class exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### In-class exercise 1: How would we select the precipitation data from July 1st and July 2nd, 2014, in Philadelphia, using label-based subsetting?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather.loc[[\"2014-7-1\",\"2014-7-2\"],[\"actual_precipitation\",\"average_precipitation\",\"record_precipitation\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### In-class exercise 2: What would we do to only select the precipitation data from July 1st and July 2nd, 2014 using index-based subsetting?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "philly_weather.iloc[0:2,9:12]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### In-class exercise 3: Using the 'all_precipitation' and 'months' objects called earlier, how can we join these dataframes together and save it as a new object titled 'all_precip_wmonths'?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_precip_wmonths = all_precipitation.join(months)\n",
    "all_precip_wmonths"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### In-class exercise 4: Go back and use the philly_weather and seattle_weather objects to figure out which days had a record minimum tempeature under 10 in either dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Answer: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_weather = philly_weather.join(seattle_weather,lsuffix = '_philly', rsuffix = '_seattle')\n",
    "all_weather[(all_weather[\"record_min_temp_philly\"] < 10) | (all_weather[\"record_min_temp_seattle\"] < 10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### In-class exercise 5: Using the all_precip_wmonths object, how would you find the differences in standard deviation in average precipitation between Philadelphia and Seattle for each month? (Hint: you may want to use the pandas function \"values\" at  some point in this answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "standard_dev_both = all_precip_wmonths[[\"actual_precipitation_philly\",\"actual_precipitation_seattle\",\"months\"]].groupby([\"months\"]).std()\n",
    "standard_dev_philly = all_precip_wmonths[[\"actual_precipitation_philly\",\"months\"]].groupby([\"months\"]).std()\n",
    "standard_dev_seattle = all_precip_wmonths[[\"actual_precipitation_seattle\",\"months\"]].groupby([\"months\"]).std()\n",
    "standard_dev_philly.values - standard_dev_seattle.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 81 different exercises pertaining to manipulating Pandas data frames found here: https://www.w3resource.com/python-exercises/pandas/index-dataframe.php (with the predicted output as well as possible solutions to the problems). \n",
    "\n",
    "I would suggest doing problems 3, 4, 5, 7, 9, 10, 12, 13, 14, 15, 24, and 31 (and if you have time/interest, problems 33, 44, 45, 49, and 52 are also good choices)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}