LCA_Blog_Part2-Cleaning_the_Data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code from Blog 1 is included for continuity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1 - Retrieve the Data from the API\n",
    "\n",
    "Now that we understand how the API request is constructed, let’s start working with our Python script. First, we need to load all of the necessary libraries.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import requests\n",
    "\n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To communicate with the API and dynamically request data for different combinations of state FIPS codes, early years, and late years, we need to employ the Requests library. Requests is a library designed to allow users to send HTTP requests with Python. In the function below, we use the method .get to request data from API and load it into a Response object r. The Requests library includes a built in JSON decoder to read the JSON data that is returned and load it into a Pandas dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dataframe(fips,early_year,late_year):\n",
    "    \"\"\"\n",
    "    Submits request for data to the API and creates formatted pandas dataframe for use with clustering algorithms\n",
    "    \n",
    "    fips = string defining the 2-digit FIPS code for your state you of interest\n",
    "    early_year = string defining the 1st date of change period (1996, 2001, 2006 or 2010)\n",
    "    late_year = string defining the 2nd date of change period (1996, 2001, 2006 or 2010)\n",
    "    \"\"\"\n",
    "    # Format inputs for url\n",
    "    fips = \"'{}'\".format(fips)\n",
    "    early_year = \"'{}'\".format(early_year)\n",
    "    late_year = \"'{}'\".format(late_year)\n",
    "    \n",
    "    #API request for Land Cover data in JSON format\n",
    "    url = \"https://coast.noaa.gov/opendata/LandCover/api/v1/distributionOfChangeGainsLossesByLandcovers?$filter=startswith(geoId, {0}) and length(geoId) eq 5 and earlyYear eq {1} and lateYear eq {2}\".format(fips, early_year, late_year)\n",
    "    \n",
    "    r = requests.get(url, headers={'Accept': 'application/json'})\n",
    "    data = r.json()\n",
    "    lca_df = pd.DataFrame(data['value'])\n",
    "    \n",
    "    # Set index to the FIPS code and drop Early and Late Year Fields\n",
    "    lca_df_index = lca_df.set_index('geoId').drop(['earlyYear', 'lateYear'], axis=1)\n",
    "    \n",
    "    return lca_df_index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will execute the function. The C-CAP Atlas has county level land cover change statistics organized by FIPS code and dates of change. C-CAP has mapped land cover for the years 1996, 2001, 2006 and 2010 using imagery acquired by the Landsat suite of satellites. This means we can look at changes in land cover that have occurred over multiple time series such as coarse intervals like 1996-2010 or we can look at finer scale changes over a 5 year period such as 2001-2006.  For this example, again we will select the state of Connecticut (FIPS code:9) and request land cover changes occurring from 2001-2010. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "CT_2001_2010 = create_dataframe('09',2001,2010)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s confirm our new object contains the correct data using the method .head( ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AgrAreaGain</th>\n",
       "      <th>AgrAreaLoss</th>\n",
       "      <th>BarAreaGain</th>\n",
       "      <th>BarAreaLoss</th>\n",
       "      <th>EmwAreaGain</th>\n",
       "      <th>EmwAreaLoss</th>\n",
       "      <th>ForAreaGain</th>\n",
       "      <th>ForAreaLoss</th>\n",
       "      <th>GrsAreaGain</th>\n",
       "      <th>GrsAreaLoss</th>\n",
       "      <th>...</th>\n",
       "      <th>LIDAreaGain</th>\n",
       "      <th>LIDAreaLoss</th>\n",
       "      <th>OSDAreaGain</th>\n",
       "      <th>OSDAreaLoss</th>\n",
       "      <th>SscbAreaGain</th>\n",
       "      <th>SscbAreaLoss</th>\n",
       "      <th>WdwAreaGain</th>\n",
       "      <th>WdwAreaLoss</th>\n",
       "      <th>WtrAreaGain</th>\n",
       "      <th>WtrAreaLoss</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>geoId</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>09001</th>\n",
       "      <td>0.31</td>\n",
       "      <td>-1.64</td>\n",
       "      <td>0.43</td>\n",
       "      <td>-0.20</td>\n",
       "      <td>0.06</td>\n",
       "      <td>-0.16</td>\n",
       "      <td>0.67</td>\n",
       "      <td>-7.58</td>\n",
       "      <td>0.41</td>\n",
       "      <td>-0.30</td>\n",
       "      <td>...</td>\n",
       "      <td>4.33</td>\n",
       "      <td>-0.49</td>\n",
       "      <td>3.61</td>\n",
       "      <td>-1.77</td>\n",
       "      <td>0.49</td>\n",
       "      <td>-0.86</td>\n",
       "      <td>0.05</td>\n",
       "      <td>-0.36</td>\n",
       "      <td>0.05</td>\n",
       "      <td>-0.20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>09003</th>\n",
       "      <td>0.71</td>\n",
       "      <td>-6.39</td>\n",
       "      <td>0.48</td>\n",
       "      <td>-0.19</td>\n",
       "      <td>0.14</td>\n",
       "      <td>-0.19</td>\n",
       "      <td>0.23</td>\n",
       "      <td>-10.56</td>\n",
       "      <td>1.06</td>\n",
       "      <td>-0.17</td>\n",
       "      <td>...</td>\n",
       "      <td>6.25</td>\n",
       "      <td>-0.45</td>\n",
       "      <td>6.91</td>\n",
       "      <td>-1.83</td>\n",
       "      <td>0.95</td>\n",
       "      <td>-1.95</td>\n",
       "      <td>0.08</td>\n",
       "      <td>-0.81</td>\n",
       "      <td>0.06</td>\n",
       "      <td>-0.26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>09005</th>\n",
       "      <td>0.60</td>\n",
       "      <td>-1.03</td>\n",
       "      <td>0.31</td>\n",
       "      <td>-0.06</td>\n",
       "      <td>0.29</td>\n",
       "      <td>-0.10</td>\n",
       "      <td>0.20</td>\n",
       "      <td>-3.89</td>\n",
       "      <td>1.36</td>\n",
       "      <td>-0.22</td>\n",
       "      <td>...</td>\n",
       "      <td>0.77</td>\n",
       "      <td>-0.06</td>\n",
       "      <td>0.97</td>\n",
       "      <td>-0.20</td>\n",
       "      <td>0.84</td>\n",
       "      <td>-0.36</td>\n",
       "      <td>0.13</td>\n",
       "      <td>-0.22</td>\n",
       "      <td>0.12</td>\n",
       "      <td>-0.28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>09007</th>\n",
       "      <td>0.30</td>\n",
       "      <td>-0.92</td>\n",
       "      <td>0.30</td>\n",
       "      <td>-0.09</td>\n",
       "      <td>0.12</td>\n",
       "      <td>-0.09</td>\n",
       "      <td>0.11</td>\n",
       "      <td>-4.09</td>\n",
       "      <td>0.24</td>\n",
       "      <td>-0.16</td>\n",
       "      <td>...</td>\n",
       "      <td>1.72</td>\n",
       "      <td>-0.11</td>\n",
       "      <td>1.37</td>\n",
       "      <td>-0.37</td>\n",
       "      <td>0.69</td>\n",
       "      <td>-0.47</td>\n",
       "      <td>0.05</td>\n",
       "      <td>-0.32</td>\n",
       "      <td>0.08</td>\n",
       "      <td>-0.15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>09009</th>\n",
       "      <td>0.36</td>\n",
       "      <td>-1.92</td>\n",
       "      <td>0.49</td>\n",
       "      <td>-0.27</td>\n",
       "      <td>0.38</td>\n",
       "      <td>-0.13</td>\n",
       "      <td>0.20</td>\n",
       "      <td>-8.45</td>\n",
       "      <td>0.75</td>\n",
       "      <td>-0.59</td>\n",
       "      <td>...</td>\n",
       "      <td>4.05</td>\n",
       "      <td>-0.43</td>\n",
       "      <td>3.93</td>\n",
       "      <td>-1.55</td>\n",
       "      <td>0.71</td>\n",
       "      <td>-1.01</td>\n",
       "      <td>0.06</td>\n",
       "      <td>-0.42</td>\n",
       "      <td>0.15</td>\n",
       "      <td>-0.48</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 22 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       AgrAreaGain  AgrAreaLoss  BarAreaGain  BarAreaLoss  EmwAreaGain  \\\n",
       "geoId                                                                    \n",
       "09001         0.31        -1.64         0.43        -0.20         0.06   \n",
       "09003         0.71        -6.39         0.48        -0.19         0.14   \n",
       "09005         0.60        -1.03         0.31        -0.06         0.29   \n",
       "09007         0.30        -0.92         0.30        -0.09         0.12   \n",
       "09009         0.36        -1.92         0.49        -0.27         0.38   \n",
       "\n",
       "       EmwAreaLoss  ForAreaGain  ForAreaLoss  GrsAreaGain  GrsAreaLoss  ...  \\\n",
       "geoId                                                                   ...   \n",
       "09001        -0.16         0.67        -7.58         0.41        -0.30  ...   \n",
       "09003        -0.19         0.23       -10.56         1.06        -0.17  ...   \n",
       "09005        -0.10         0.20        -3.89         1.36        -0.22  ...   \n",
       "09007        -0.09         0.11        -4.09         0.24        -0.16  ...   \n",
       "09009        -0.13         0.20        -8.45         0.75        -0.59  ...   \n",
       "\n",
       "       LIDAreaGain  LIDAreaLoss  OSDAreaGain  OSDAreaLoss  SscbAreaGain  \\\n",
       "geoId                                                                     \n",
       "09001         4.33        -0.49         3.61        -1.77          0.49   \n",
       "09003         6.25        -0.45         6.91        -1.83          0.95   \n",
       "09005         0.77        -0.06         0.97        -0.20          0.84   \n",
       "09007         1.72        -0.11         1.37        -0.37          0.69   \n",
       "09009         4.05        -0.43         3.93        -1.55          0.71   \n",
       "\n",
       "       SscbAreaLoss  WdwAreaGain  WdwAreaLoss  WtrAreaGain  WtrAreaLoss  \n",
       "geoId                                                                    \n",
       "09001         -0.86         0.05        -0.36         0.05        -0.20  \n",
       "09003         -1.95         0.08        -0.81         0.06        -0.26  \n",
       "09005         -0.36         0.13        -0.22         0.12        -0.28  \n",
       "09007         -0.47         0.05        -0.32         0.08        -0.15  \n",
       "09009         -1.01         0.06        -0.42         0.15        -0.48  \n",
       "\n",
       "[5 rows x 22 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CT_2001_2010.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also get a list of the column names by using the following code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AgrAreaGain',\n",
       " 'AgrAreaLoss',\n",
       " 'BarAreaGain',\n",
       " 'BarAreaLoss',\n",
       " 'EmwAreaGain',\n",
       " 'EmwAreaLoss',\n",
       " 'ForAreaGain',\n",
       " 'ForAreaLoss',\n",
       " 'GrsAreaGain',\n",
       " 'GrsAreaLoss',\n",
       " 'HIDAreaGain',\n",
       " 'HIDAreaLoss',\n",
       " 'LIDAreaGain',\n",
       " 'LIDAreaLoss',\n",
       " 'OSDAreaGain',\n",
       " 'OSDAreaLoss',\n",
       " 'SscbAreaGain',\n",
       " 'SscbAreaLoss',\n",
       " 'WdwAreaGain',\n",
       " 'WdwAreaLoss',\n",
       " 'WtrAreaGain',\n",
       " 'WtrAreaLoss']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(CT_2001_2010.columns.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Cleaning the Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The objective of this blog post is to introduce some ways we can use the Pandas and GeoPandas libraries to prepare the data we retrieved from the Land Cover Atlas API and get it ready for exploratory analysis with unsupervised machine learning algorithms.  Additionally, we will acquire spatial data from the U.S. Census to be enable us to visualize the results.  To get started, let's import the required libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import geopandas as gpd\n",
    "import requests\n",
    "import zipfile\n",
    "import io\n",
    "\n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we have loaded all of the necessary libraries,  we are going to need a shapefile representing the county boundaries for the entire U.S. Fortunately, we can easily download a TIGER/Line shapefile from our buddies at the U.S. Census Bureau.  We want to incorporate this data set into our project for 2 purposes:\n",
    "\n",
    "1. Add county names to our Land Cover change DataFrame\n",
    "2. Visualize the results of our exploratory analysis spatially\n",
    "\n",
    "We will talk more about visualization in the next blog post. In the meantime, we can use the function below to download the TIGER/Line shapefile from Census using Requests, unzip it using the Zipfile library and import the shapefile into a GeoPandas GeoDataFrame. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def download_shapefile(url, directory):\n",
    "    \"\"\"\n",
    "    Download a shapefile in .zip format from a ftp site. Unzips shapefile and \n",
    "    loads it into a GeoPandas GeoDataFrame\n",
    "    \"\"\"          \n",
    "    print('Downloading shapefile...')\n",
    "        \n",
    "    # Split on the URL on rightmost / and take everything on the right side of that\n",
    "    # Replace .zip file extension with .shp\n",
    "    shapefile = url.rsplit('/', 1)[-1].replace(\".zip\",\".shp\")\n",
    "    \n",
    "    r = requests.get(url)\n",
    "    # Keep contents of the response object as bytes in an in-memory buffer using IO\n",
    "    zipfile.ZipFile(io.BytesIO(r.content)).extractall(directory)\n",
    "            \n",
    "    # Read the shapefile into GeoPandas GeoDataframe   \n",
    "    nation = gpd.read_file(os.path.join(directory,shapefile))\n",
    "    \n",
    "    return nation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Execute the function, downloading the data to the directory of your choice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading shapefile...\n"
     ]
    }
   ],
   "source": [
    "url = \"https://www2.census.gov/geo/tiger/TIGER2017/COUNTY/tl_2017_us_county.zip\"\n",
    "us_counties = download_shapefile(url,\"C:\\\\Projects\\\\Cluster\") # Be sure to rename the directory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with GeoPandas Dataframes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GeoPandas is an excellent open source library which facilitates working with spatial data in Python. It does this by leveraging the capabilities of the Pandas and Shapely libraries.  Since we have access to all of the operations available in Pandas, let's go ahead and inspect the attributes of our GeoPandas GeoDataFrame using the .info( ) method. This will provide us with a summary of the GeoDataFrame with information such as column data types and non-null values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'geopandas.geodataframe.GeoDataFrame'>\n",
      "RangeIndex: 3233 entries, 0 to 3232\n",
      "Data columns (total 18 columns):\n",
      "STATEFP     3233 non-null object\n",
      "COUNTYFP    3233 non-null object\n",
      "COUNTYNS    3233 non-null object\n",
      "GEOID       3233 non-null object\n",
      "NAME        3233 non-null object\n",
      "NAMELSAD    3233 non-null object\n",
      "LSAD        3233 non-null object\n",
      "CLASSFP     3233 non-null object\n",
      "MTFCC       3233 non-null object\n",
      "CSAFP       1231 non-null object\n",
      "CBSAFP      1899 non-null object\n",
      "METDIVFP    113 non-null object\n",
      "FUNCSTAT    3233 non-null object\n",
      "ALAND       3233 non-null int64\n",
      "AWATER      3233 non-null int64\n",
      "INTPTLAT    3233 non-null object\n",
      "INTPTLON    3233 non-null object\n",
      "geometry    3233 non-null object\n",
      "dtypes: int64(2), object(16)\n",
      "memory usage: 454.7+ KB\n"
     ]
    }
   ],
   "source": [
    "us_counties.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x22c323eacc0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "us_counties.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'll admit it's not the most visually appealing map but this provides us with a quick way to verify the geography is correct. \n",
    "\n",
    "Now that we have created a GeoPandas Dataframe, let's leverage some more of those tools available in the Pandas library. Let’s create a new GeoDataFrame that consists of a single coastal state. This can be performed using the .loc method which allows us to access groups of rows and columns. Here we will make our selection based on a state’s FIPS codes to make a new GeoDataFrame.\n",
    "\n",
    "Now that we have made our selection, let's do some cleaning. First things first. Let's eliminate some redundancy. You may have noticed when inspecting the attributes of the GeoDataFrame that there are 2 columns containing county names, NAME and NAMELSAD. Let's use the .drop() method to remove the column called NAME. We also will use the .rename method to rename the GEOID and NAMELSAD columns. Renaming GEOID to geoId is required to enable joining with the land cover data we retrieved from the API. To reduce the lines of code and number of variables required, the methods are chained together on one line. This is a great feature within Python but be careful not to abuse it! See the function below.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_state(fips, nation):\n",
    "    \"\"\"\n",
    "    Creates new GeoDataFrame based on FIPS code\n",
    "    \n",
    "    fips:the 2-digit FIPS code for your state you of interest\n",
    "    nation: GeoDataFrame of census counties\n",
    "    \"\"\"\n",
    "      \n",
    "    counties = nation.loc[nation['STATEFP'] == '{0}'.format(fips)].squeeze()\n",
    "    counties = counties.drop(columns=['NAME']).rename(columns={'GEOID': 'geoId','NAMELSAD': 'name'})\n",
    "        \n",
    "    #return counties\n",
    "    return counties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we will execute the function. For this example we will select the state of Connecticut (FIPS code: 09). Make sure the FIPS code is provided as a String!  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "counties_gdf = select_state('09', us_counties)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just to confirm our new object contains changes we made to the columns, let’s use the Pandas method .columns to view a full list of the labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['STATEFP', 'COUNTYFP', 'COUNTYNS', 'geoId', 'name', 'LSAD', 'CLASSFP',\n",
       "       'MTFCC', 'CSAFP', 'CBSAFP', 'METDIVFP', 'FUNCSTAT', 'ALAND', 'AWATER',\n",
       "       'INTPTLAT', 'INTPTLON', 'geometry'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counties_gdf.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like the modifications are present. While we are at it. Let's use .plot( ) again to check our geography. If everything looks good, we are going to set the GeoDataFrame aside for use in the next blog post."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1d7fcf785f8>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "counties_gdf.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may have noticed earlier when you inspected the DataFrame of land cover change data that the table only includes FIPS codes. When it comes time to make visualizations of our analysis is may be helpful to be able use the actual county names as labels. To do this, let’s create another Pandas DataFrame with county names and FIPs codes for our state of interest using the GeoPandas GeoDataFrame we created in the last section.  We will accomplish this by using square brackets [ ] to select specific columns (geoId & name) from the GeoDataFrame. To make the upcoming merge process work, we'll need to set the resulting DataFrame's index to the FIPS code ('geoId') using the .set_index( ) method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_fips_table(dataframe):\n",
    "    \"\"\"\n",
    "    Creates table of FIPS codes and county names for joining to Land Cover DataFrame\n",
    "    \n",
    "    dataframe: Geopandas dataframe of State of interest\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    county_attributes = pd.DataFrame(dataframe)\n",
    "    fips_names = county_attributes[['geoId','name']].set_index('geoId')\n",
    "    \n",
    "    return fips_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's execute the function.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "fips_df = create_fips_table(counties_gdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once again, let’s confirm our new object contains the correct data using the method .head( )  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>geoId</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>09007</th>\n",
       "      <td>Middlesex County</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>09011</th>\n",
       "      <td>New London County</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>09009</th>\n",
       "      <td>New Haven County</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>09013</th>\n",
       "      <td>Tolland County</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>09003</th>\n",
       "      <td>Hartford County</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    name\n",
       "geoId                   \n",
       "09007   Middlesex County\n",
       "09011  New London County\n",
       "09009   New Haven County\n",
       "09013     Tolland County\n",
       "09003    Hartford County"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fips_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_dataframes(dataframe,fips_names_df):\n",
    "    \"\"\"\n",
    "    Merges county names to land cover dataframe based on FIPS code\n",
    "    \n",
    "    dataframe: DataFrame with Land Cover change data\n",
    "    fips_names_df: DataFrame with FIPS codes and County Names\n",
    "    \"\"\"\n",
    "    fips_names_index_df = pd.merge(dataframe, fips_names_df,left_index=True,right_index=True).set_index('name')\n",
    "        \n",
    "    return fips_names_index_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the function below, we use the Pandas method .merge( ) to perform a database-style join of  the county FIPS and names DataFrame with LC Change Dataframe we created from the API. We also use the .set_index( ) method to set the names column as the index of the resulting DataFrame. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "CT_2001_2010_index = merge_dataframes(CT_2001_2010, fips_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once again, let’s confirm our new object contains the correct data using the method .info( )  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 8 entries, Fairfield County to Windham County\n",
      "Data columns (total 22 columns):\n",
      "AgrAreaGain     8 non-null float64\n",
      "AgrAreaLoss     8 non-null float64\n",
      "BarAreaGain     8 non-null float64\n",
      "BarAreaLoss     8 non-null float64\n",
      "EmwAreaGain     8 non-null float64\n",
      "EmwAreaLoss     8 non-null float64\n",
      "ForAreaGain     8 non-null float64\n",
      "ForAreaLoss     8 non-null float64\n",
      "GrsAreaGain     8 non-null float64\n",
      "GrsAreaLoss     8 non-null float64\n",
      "HIDAreaGain     8 non-null float64\n",
      "HIDAreaLoss     8 non-null float64\n",
      "LIDAreaGain     8 non-null float64\n",
      "LIDAreaLoss     8 non-null float64\n",
      "OSDAreaGain     8 non-null float64\n",
      "OSDAreaLoss     8 non-null float64\n",
      "SscbAreaGain    8 non-null float64\n",
      "SscbAreaLoss    8 non-null float64\n",
      "WdwAreaGain     8 non-null float64\n",
      "WdwAreaLoss     8 non-null float64\n",
      "WtrAreaGain     8 non-null float64\n",
      "WtrAreaLoss     8 non-null float64\n",
      "dtypes: float64(22)\n",
      "memory usage: 1.4+ KB\n"
     ]
    }
   ],
   "source": [
    "CT_2001_2010_index.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And there you have it. You have officially used the Pandas library to clean data sets you retrieved from an API and downloaded from a website. You have sliced columns, dropped columns, renamed columns, set indexes and merged DataFrames. Really, that is just a small sample of what you can do in Pandas. Next, we get down to the nitty gritty and explore our data using unsupervised machine learning. See you soon!\n",
    "    \n",
    "Chris\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}