Biodiversity-Capstone.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Codecademy Intro to Data Analysis Capstone: Biodiversity Project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "You are a biodiversity analyst working for the National Parks Service.  You're going to help them analyze some data about species at various national parks.\n",
    "\n",
    "Note: The data that you'll be working with for this project is *inspired* by real data, but is mostly fictional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 1\n",
    "Import the modules that you'll be using in this assignment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 2\n",
    "You have been given two CSV files. `species_info.csv` with data about different species in our National Parks, including:\n",
    "- The scientific name of each species\n",
    "- The common names of each species\n",
    "- The species conservation status\n",
    "\n",
    "Load the dataset and inspect it:\n",
    "- Load `species_info.csv` into a DataFrame called `species`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "species = pd.read_csv('species_info.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inspect each DataFrame using `.head()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  category                scientific_name  \\\n",
      "0   Mammal  Clethrionomys gapperi gapperi   \n",
      "1   Mammal                      Bos bison   \n",
      "2   Mammal                     Bos taurus   \n",
      "3   Mammal                     Ovis aries   \n",
      "4   Mammal                 Cervus elaphus   \n",
      "\n",
      "                                        common_names conservation_status  \n",
      "0                           Gapper's Red-Backed Vole                 NaN  \n",
      "1                              American Bison, Bison                 NaN  \n",
      "2  Aurochs, Aurochs, Domestic Cattle (Feral), Dom...                 NaN  \n",
      "3  Domestic Sheep, Mouflon, Red Sheep, Sheep (Feral)                 NaN  \n",
      "4                                      Wapiti Or Elk                 NaN  \n"
     ]
    }
   ],
   "source": [
    "print(species.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 3\n",
    "Let's start by learning a bit more about our data.  Answer each of the following questions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many different species are in the `species` DataFrame?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5824\n"
     ]
    }
   ],
   "source": [
    "species_count = species.scientific_name.count()\n",
    "print(species_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What are the different values of `category` in `species`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "species_type = species.category.nunique()\n",
    "print(species_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What are the different values of `conservation_status`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nan 'Species of Concern' 'Endangered' 'Threatened' 'In Recovery']\n"
     ]
    }
   ],
   "source": [
    "conservation_statuses = species.conservation_status.unique()\n",
    "print(conservation_statuses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 4\n",
    "Let's start doing some analysis!\n",
    "\n",
    "The column `conservation_status` has several possible values:\n",
    "- `Species of Concern`: declining or appear to be in need of conservation\n",
    "- `Threatened`: vulnerable to endangerment in the near future\n",
    "- `Endangered`: seriously at risk of extinction\n",
    "- `In Recovery`: formerly `Endangered`, but currnetly neither in danger of extinction throughout all or a significant portion of its range\n",
    "\n",
    "We'd like to count up how many species meet each of these criteria.  Use `groupby` to count how many `scientific_name` meet each of these criteria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  conservation_status  scientific_name\n",
      "0          Endangered               15\n",
      "1         In Recovery                4\n",
      "2  Species of Concern              151\n",
      "3          Threatened               10\n"
     ]
    }
   ],
   "source": [
    "conservation_counts = species.groupby('conservation_status').scientific_name.nunique().reset_index()\n",
    "print(conservation_counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we saw before, there are far more than 200 species in the `species` table.  Clearly, only a small number of them are categorized as needing some sort of protection.  The rest have `conservation_status` equal to `None`.  Because `groupby` does not include `None`, we will need to fill in the null values.  We can do this using `.fillna`.  We pass in however we want to fill in our `None` values as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "species.fillna('No Intervention', inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! Now run the same `groupby` as before to see how many species require `No Intervention`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conservation_status\n",
      "Endangered              16\n",
      "In Recovery              4\n",
      "No Intervention       5633\n",
      "Species of Concern     161\n",
      "Threatened              10\n",
      "Name: scientific_name, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(species.groupby('conservation_status').scientific_name.count())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use `plt.bar` to create a bar chart.  First, let's sort the columns by how many species are in each categories.  We can do this using `.sort_values`.  We use the the keyword `by` to indicate which column we want to sort by."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "protection_counts = species.groupby('conservation_status')\\\n",
    "    .scientific_name.nunique().reset_index()\\\n",
    "    .sort_values(by='scientific_name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's create a bar chart!\n",
    "1. Start by creating a wide figure with `figsize=(10, 4)`\n",
    "1. Start by creating an axes object called `ax` using `plt.subplot`.\n",
    "2. Create a bar chart whose heights are equal to `scientific_name` column of `protection_counts`.\n",
    "3. Create an x-tick for each of the bars.\n",
    "4. Label each x-tick with the label from `conservation_status` in `protection_counts`\n",
    "5. Label the y-axis `Number of Species`\n",
    "6. Title the graph `Conservation Status by Species`\n",
    "7. Plot the grap using `plt.show()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 4))\n",
    "ax = plt.subplot()\n",
    "\n",
    "plt.bar(range(len((protection_counts.conservation_status))), protection_counts.scientific_name.values)\n",
    "\n",
    "ax.set_xticks(range(len(protection_counts.conservation_status)))\n",
    "ax.set_xticklabels(protection_counts.conservation_status.values)\n",
    "\n",
    "plt.ylabel('Number of Species')\n",
    "ax.set_title('Conservation Status by Species')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 5\n",
    "Are certain types of species more likely to be endangered?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a new column in `species` called `is_protected`, which is `True` if `conservation_status` is not equal to `No Intervention`, and `False` otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "species['is_protected'] = species.conservation_status != 'No Intervention'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's group the `species` data frame by the `category` and `is_protected` columns and count the unique `scientific_name`s in each grouping.\n",
    "\n",
    "Save your results to `category_counts`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "category_counts = species.groupby(['category', 'is_protected']).scientific_name.count().reset_index()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Examine `category_counts` using `head()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    category  is_protected  scientific_name\n",
      "0  Amphibian         False               73\n",
      "1  Amphibian          True                7\n",
      "2       Bird         False              442\n",
      "3       Bird          True               79\n",
      "4       Fish         False              116\n"
     ]
    }
   ],
   "source": [
    "print(category_counts.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "It's going to be easier to view this data if we pivot it.  Using `pivot`, rearange `category_counts` so that:\n",
    "- `columns` is `is_protected`\n",
    "- `index` is `category`\n",
    "- `values` is `scientific_name`\n",
    "\n",
    "Save your pivoted data to `category_pivot`. Remember to `reset_index()` at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "category_pivot = category_counts.pivot(columns='is_protected', index='category', values='scientific_name').reset_index()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Examine `category_pivot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "is_protected           category  False  True\n",
      "0                     Amphibian     73     7\n",
      "1                          Bird    442    79\n",
      "2                          Fish    116    11\n",
      "3                        Mammal    176    38\n",
      "4             Nonvascular Plant    328     5\n"
     ]
    }
   ],
   "source": [
    "print(category_pivot.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the `.columns` property to  rename the categories `True` and `False` to something more description:\n",
    "- Leave `category` as `category`\n",
    "- Rename `False` to `not_protected`\n",
    "- Rename `True` to `protected`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "category_pivot.columns= ['category', 'not_protected', 'protected']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a new column of `category_pivot` called `percent_protected`, which is equal to `protected` (the number of species that are protected) divided by `protected` plus `not_protected` (the total number of species)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "category_pivot['percent_protected'] = category_pivot.protected/ (category_pivot.protected + category_pivot.not_protected)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Examine `category_pivot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            category  not_protected  protected  percent_protected\n",
      "0          Amphibian             73          7           0.087500\n",
      "1               Bird            442         79           0.151631\n",
      "2               Fish            116         11           0.086614\n",
      "3             Mammal            176         38           0.177570\n",
      "4  Nonvascular Plant            328          5           0.015015\n"
     ]
    }
   ],
   "source": [
    "print(category_pivot.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like species in category `Mammal` are more likely to be endangered than species in `Bird`.  We're going to do a significance test to see if this statement is true.  Before you do the significance test, consider the following questions:\n",
    "- Is the data numerical or categorical?\n",
    "- How many pieces of data are you comparing?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on those answers, you should choose to do a *chi squared test*.  In order to run a chi squared test, we'll need to create a contingency table.  Our contingency table should look like this:\n",
    "\n",
    "||protected|not protected|\n",
    "|-|-|-|\n",
    "|Mammal|?|?|\n",
    "|Bird|?|?|\n",
    "\n",
    "Create a table called `contingency` and fill it in with the correct numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "contingency = [[38, 176],\n",
    "              [79, 442]]                             "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to perform our chi square test, we'll need to import the correct function from scipy.  Past the following code and run it:\n",
    "```py\n",
    "from scipy.stats import chi2_contingency\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import chi2_contingency"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now run `chi2_contingency` with `contingency`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.445901703047197\n"
     ]
    }
   ],
   "source": [
    "pval = chi2_contingency(contingency)[1]\n",
    "print(pval)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like this difference isn't significant!\n",
    "\n",
    "Let's test another.  Is the difference between `Reptile` and `Mammal` significant?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.02338465214871547\n"
     ]
    }
   ],
   "source": [
    "contingency2 = [[38, 176],\n",
    "              [5, 74]] \n",
    "pval = chi2_contingency(contingency2)[1]\n",
    "print(pval)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes! It looks like there is a significant difference between `Reptile` and `Mammal`!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conservationists have been recording sightings of different species at several national parks for the past 7 days.  They've saved sent you their observations in a file called `observations.csv`.  Load `observations.csv` into a variable called `observations`, then use `head` to view the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            scientific_name                            park_name  observations\n",
      "0        Vicia benghalensis  Great Smoky Mountains National Park            68\n",
      "1            Neovison vison  Great Smoky Mountains National Park            77\n",
      "2         Prunus subcordata               Yosemite National Park           138\n",
      "3      Abutilon theophrasti                  Bryce National Park            84\n",
      "4  Githopsis specularioides  Great Smoky Mountains National Park            85\n"
     ]
    }
   ],
   "source": [
    "observations = pd.read_csv('observations.csv')\n",
    "print(observations.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some scientists are studying the number of sheep sightings at different national parks.  There are several different scientific names for different types of sheep.  We'd like to know which rows of `species` are referring to sheep.  Notice that the following code will tell us whether or not a word occurs in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Does \"Sheep\" occur in this string?\n",
    "str1 = 'This string contains Sheep'\n",
    "'Sheep' in str1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Does \"Sheep\" occur in this string?\n",
    "str2 = 'This string contains Cows'\n",
    "'Sheep' in str2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `apply` and a `lambda` function to create a new column in `species` called `is_sheep` which is `True` if the `common_names` contains `'Sheep'`, and `False` otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "species['is_sheep'] = species.common_names.apply(lambda x : x == 'Sheep' in common_names)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select the rows of `species` where `is_sheep` is `True` and examine the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  category                scientific_name  \\\n",
      "0   Mammal  Clethrionomys gapperi gapperi   \n",
      "1   Mammal                      Bos bison   \n",
      "2   Mammal                     Bos taurus   \n",
      "3   Mammal                     Ovis aries   \n",
      "4   Mammal                 Cervus elaphus   \n",
      "\n",
      "                                        common_names conservation_status  \\\n",
      "0                           Gapper's Red-Backed Vole     No Intervention   \n",
      "1                              American Bison, Bison     No Intervention   \n",
      "2  Aurochs, Aurochs, Domestic Cattle (Feral), Dom...     No Intervention   \n",
      "3  Domestic Sheep, Mouflon, Red Sheep, Sheep (Feral)     No Intervention   \n",
      "4                                      Wapiti Or Elk     No Intervention   \n",
      "\n",
      "   is_protected  is_sheep  \n",
      "0         False     False  \n",
      "1         False     False  \n",
      "2         False     False  \n",
      "3         False      True  \n",
      "4         False     False  \n"
     ]
    }
   ],
   "source": [
    "species['is_sheep'] = species.common_names.apply(lambda x: 'Sheep' in x)\n",
    "\n",
    "print(species.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many of the results are actually plants.  Select the rows of `species` where `is_sheep` is `True` and `category` is `Mammal`.  Save the results to the variable `sheep_species`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sheep_species = species[(species.is_sheep == True) & (species.category == 'Mammal')]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now merge `sheep_species` with `observations` to get a DataFrame with observations of sheep.  Save this DataFrame as `sheep_observations`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  category  scientific_name  \\\n",
      "0   Mammal       Ovis aries   \n",
      "1   Mammal       Ovis aries   \n",
      "2   Mammal       Ovis aries   \n",
      "3   Mammal       Ovis aries   \n",
      "4   Mammal  Ovis canadensis   \n",
      "\n",
      "                                        common_names conservation_status  \\\n",
      "0  Domestic Sheep, Mouflon, Red Sheep, Sheep (Feral)     No Intervention   \n",
      "1  Domestic Sheep, Mouflon, Red Sheep, Sheep (Feral)     No Intervention   \n",
      "2  Domestic Sheep, Mouflon, Red Sheep, Sheep (Feral)     No Intervention   \n",
      "3  Domestic Sheep, Mouflon, Red Sheep, Sheep (Feral)     No Intervention   \n",
      "4                       Bighorn Sheep, Bighorn Sheep  Species of Concern   \n",
      "\n",
      "   is_protected  is_sheep                            park_name  observations  \n",
      "0         False      True               Yosemite National Park           126  \n",
      "1         False      True  Great Smoky Mountains National Park            76  \n",
      "2         False      True                  Bryce National Park           119  \n",
      "3         False      True            Yellowstone National Park           221  \n",
      "4          True      True            Yellowstone National Park           219  \n"
     ]
    }
   ],
   "source": [
    "sheep_observations = pd.merge(sheep_species, observations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many total sheep observations (across all three species) were made at each national park?  Use `groupby` to get the `sum` of `observations` for each `park_name`.  Save your answer to `obs_by_park`.\n",
    "\n",
    "This is the total number of sheep observed in each park over the past 7 days."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                             park_name  observations\n",
      "0                  Bryce National Park           250\n",
      "1  Great Smoky Mountains National Park           149\n",
      "2            Yellowstone National Park           507\n",
      "3               Yosemite National Park           282\n"
     ]
    }
   ],
   "source": [
    "obs_by_park = sheep_observations.groupby('park_name').observations.sum().reset_index()\n",
    "\n",
    "print(obs_by_park.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a bar chart showing the different number of observations per week at each park.\n",
    "\n",
    "1. Start by creating a wide figure with `figsize=(16, 4)`\n",
    "1. Start by creating an axes object called `ax` using `plt.subplot`.\n",
    "2. Create a bar chart whose heights are equal to `observations` column of `obs_by_park`.\n",
    "3. Create an x-tick for each of the bars.\n",
    "4. Label each x-tick with the label from `park_name` in `obs_by_park`\n",
    "5. Label the y-axis `Number of Observations`\n",
    "6. Title the graph `Observations of Sheep per Week`\n",
    "7. Plot the grap using `plt.show()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(16, 4))\n",
    "ax = plt.subplot()\n",
    "plt.bar(range(len(obs_by_park)),\n",
    "        obs_by_park.observations.values)\n",
    "ax.set_xticks(range(len(obs_by_park)))\n",
    "ax.set_xticklabels(obs_by_park.park_name.values)\n",
    "plt.ylabel('Number of Observations')\n",
    "plt.title('Observations of Sheep per Week')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our scientists know that 15% of sheep at Bryce National Park have foot and mouth disease.  Park rangers at Yellowstone National Park have been running a program to reduce the rate of foot and mouth disease at that park.  The scientists want to test whether or not this program is working.  They want to be able to detect reductions of at least 5 percentage points.  For instance, if 10% of sheep in Yellowstone have foot and mouth disease, they'd like to be able to know this, with confidence.\n",
    "\n",
    "Use <a href=\"https://s3.amazonaws.com/codecademy-content/courses/learn-hypothesis-testing/a_b_sample_size/index.html\">Codecademy's sample size calculator</a> to calculate the number of sheep that they would need to observe from each park.  Use the default level of significance (90%).\n",
    "\n",
    "Remember that \"Minimum Detectable Effect\" is a percent of the baseline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "minimum_detectable_effect = 100*5./15\n",
    "sample_size_per_variant = 870"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many weeks would you need to observe sheep at Bryce National Park in order to observe enough sheep?  How many weeks would you need to observe at Yellowstone National Park to observe enough sheep?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "bryce_weeks_observing = sample_size_per_variant/250."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "yellowstone_weeks_observing = sample_size_per_variant/507."
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}