lefty_longevity_with_solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Do Left-Handed People Really Die Young?\n",
    "\n",
    "Use pandas and Bayesian statistics to see if the urban legend is true that lefties die earlier than righties.\n",
    "\n",
    "The content of this project is nearly identical to a DataCamp project I created at the end of 2018, but this version is free!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to use this notebook\n",
    "\n",
    "This notebook contains a series of cell blocks that fall into one of six types:\n",
    "\n",
    "* **Context:** a text cell following a numbered title that contains background information about a task.\n",
    "* **Instructions:** a text cell that contains the specific instructions for a task.\n",
    "* **Hint:** a hint about how to accomplish the coding task.\n",
    "* **Sample code:** scaffolding code to get you started on completing a task.\n",
    "* **Solution:** my solution code for the task. This code will pass all the tests in the following cell.\n",
    "* **Tests:** tests to check solutions for the task.\n",
    "\n",
    "If you'd just like to see the entire project, you can read this notebook from top to bottom, glossing over the **hint**, **sample code**, and **tests** sections. \n",
    "\n",
    "If you'd like to work on this project as an exercise, stop here and go to [this other notebook instead](https://github.com/mbonsma/lefty-longevity/blob/master/lefty_longevity_workbook.ipynb)! It's the same as this notebook, but the solution code has been removed so that you can work on and try your own solutions. If you ever want to peek at the answers though, just come right back here. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is the module to run the tests\n",
    "%load_ext ipython_nose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "type:NotebookTask"
    ]
   },
   "source": [
    "## 1. Where are the old left-handed people?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@context"
    ]
   },
   "source": [
    "![Barack Obama signs the Patient Protection and Affordable Care Act at the White House, March 23, 2010](img/Obama_signs_health_care-20100323.jpg)\n",
    "\n",
    "Barack Obama is left-handed. So are Bill Gates and Oprah Winfrey; so were Babe Ruth and Marie Curie. A [1991 study](https://www.nejm.org/doi/full/10.1056/NEJM199104043241418) reported that left-handed people die on average nine years earlier than right-handed people. Nine years! Could this really be true? \n",
    "\n",
    "In this notebook, we will explore this phenomenon using age distribution data to see if we can reproduce a difference in average age at death purely from the changing rates of left-handedness over time, refuting the claim of early death for left-handers. This notebook uses `pandas` and Bayesian statistics to analyze the probability of being a certain age at death given that you are reported as left-handed or right-handed.\n",
    "\n",
    "A National Geographic survey in 1986 resulted in over a million responses that included age, sex, and hand preference for throwing and writing. Researchers Avery Gilbert and Charles Wysocki analyzed this data and noticed that rates of left-handedness were around 13% for people younger than 40 but decreased with age to about 5% by the age of 80. They concluded based on analysis of a subgroup of people who throw left-handed but write right-handed that this age-dependence was primarily due to changing social acceptability of left-handedness. This means that the rates aren't a factor of *age* specifically but rather of the *year you were born*, and if the same study was done today, we should expect a shifted version of the same distribution as a function of age. Ultimately, we'll see what effect this changing rate has on the apparent mean age of death of left-handed people, but let's start by plotting the rates of left-handedness as a function of age.\n",
    "\n",
    "This notebook uses two datasets: [death distribution data](https://www.cdc.gov/nchs/data/statab/vs00199_table310.pdf) for the United States from the year 1999 (source website [here](https://www.cdc.gov/nchs/nvss/mortality_tables.htm)) and rates of left-handedness digitized from a figure in this [1992 paper by Gilbert and Wysocki](https://www.ncbi.nlm.nih.gov/pubmed/1528408). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@instructions"
    ]
   },
   "source": [
    "Load the handedness data from the National Geographic survey and create a scatter plot.\n",
    "\n",
    "- Import `pandas` as `pd`  and `matplotlib.pyplot` as `plt`.\n",
    "- Load the data into a pandas DataFrame named `lefthanded_data` using the provided `data_url_1`. Note that the file is a CSV file.\n",
    "- Use the `.plot()` method to create a plot of the \"Male\" and \"Female\" columns vs. \"Age\".\n",
    "\n",
    "<hr>\n",
    "\n",
    "## Good to know\n",
    "\n",
    "This project requires the use of `pandas`, Bayesian statistics and probability, and data visualization. Some specific skills focused on here are reading data, creating new columns, creating `matplotlib` visualizations, using `numpy` arrays, constructing probabilities from frequency data, and Bayes' theorem. \n",
    "\n",
    "Helpful links:\n",
    "- pandas [cheat sheet](https://pandas.pydata.org/Pandas_Cheat_Sheet.pdf)\n",
    "- pandas `read_csv()` function [documentation](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html)\n",
    "- numpy [tutorial](https://docs.scipy.org/doc/numpy/user/quickstart.html)\n",
    "- matplotlib [tutorial](https://matplotlib.org/tutorials/introductory/pyplot.html)\n",
    "- [short intro to Python functions](https://www.w3schools.com/python/python_functions.asp)\n",
    "- [Bayes' theorem on Wikipedia](https://en.wikipedia.org/wiki/Bayes%27_theorem)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@hint"
    ]
   },
   "source": [
    "You can read `https://data_url.csv` into a DataFrame named `my_data` like this after importing the `pandas` library:\n",
    "\n",
    "```python\n",
    "import pandas as pd\n",
    "my_data = pd.read_csv(\"https://data_url.csv\")\n",
    "```\n",
    "\n",
    "You can plot columns from a `pandas` DataFrame like this after importing the `matplotlib` library:\n",
    "\n",
    "```python\n",
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(\"x_column\", \"y_column\", data = my_data)\n",
    "ax.set_xlabel(\"Label for the x axis of the plot\")\n",
    "ax.set_ylabel(\"Label for the y axis of the plot\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "@sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "# import libraries\n",
    "# ... YOUR CODE FOR TASK 1 ...\n",
    "\n",
    "# load the data\n",
    "data_url_1 = \"https://gist.githubusercontent.com/mbonsma/8da0990b71ba9a09f7de395574e54df1/raw/aec88b30af87fad8d45da7e774223f91dad09e88/lh_data.csv\"\n",
    "lefthanded_data = ...\n",
    "\n",
    "# plot male and female left-handedness rates vs. age\n",
    "%matplotlib inline\n",
    "fig, ax = plt.subplots() # create figure and axis objects\n",
    "ax.plot(..., ..., ..., marker = 'o') # plot \"Female\" vs. \"Age\"\n",
    "ax.plot(..., ..., ..., marker = 'x') # plot \"Male\" vs. \"Age\"\n",
    "ax.legend() # add a legend\n",
    "ax.set_xlabel(...)\n",
    "ax.set_ylabel(...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "@solution"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7fd3f6274588>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fd40e5157f0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import libraries\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# load the data\n",
    "data_url_1 = \"https://gist.githubusercontent.com/mbonsma/8da0990b71ba9a09f7de395574e54df1/raw/aec88b30af87fad8d45da7e774223f91dad09e88/lh_data.csv\"\n",
    "lefthanded_data = pd.read_csv(data_url_1, sep = ',')\n",
    "\n",
    "# plot male and female left-handedness rates vs. age\n",
    "%matplotlib inline\n",
    "fig, ax = plt.subplots() # create figure and axis objects\n",
    "ax.plot('Age', 'Female', data = lefthanded_data, marker='o') # plot \"Female\" vs. \"Age\"\n",
    "ax.plot('Age', 'Male', data = lefthanded_data, marker = 'x') # plot \"Male\" vs. \"Age\"\n",
    "ax.legend() # add a legend\n",
    "ax.set_xlabel(\"Age\")\n",
    "ax.set_ylabel(\"Percentage of people who are left-handed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "@tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 4, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_data_shape\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_num_lines\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_plot_dimensions\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_plot_labels\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "4/4 tests passed\n"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "def test_data_shape():\n",
    "    assert (lefthanded_data.shape == (77, 3)), \\\n",
    "    'The lefthanded_data you loaded is not the right shape. It should be 77, 3.'\n",
    "    \n",
    "def test_num_lines():\n",
    "    assert (len(ax.lines) == 2), \\\n",
    "    'Did you plot lefthanded rates for both men and women?'\n",
    "    \n",
    "def test_plot_dimensions():\n",
    "     assert ((ax.get_yticks()[-1] < 20) and (ax.get_xticks()[-1] > 20)), \\\n",
    "     'Did you plot \"Female\" vs. \"Age\" and \"Male\" vs. \"Age\"?'\n",
    "\n",
    "def test_plot_labels():\n",
    "    assert ax.get_xlabel() != '' and ax.get_ylabel() != '', \\\n",
    "    'Please add x and y labels to your plot.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "type:NotebookTask"
    ]
   },
   "source": [
    "## 2. Rates of left-handedness over time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@context"
    ]
   },
   "source": [
    "Let's convert this data into a plot of the rates of left-handedness as a function of the year of birth, and average over male and female to get a single rate for both sexes. \n",
    "\n",
    "Since the study was done in 1986, the data after this conversion will be the percentage of people alive in 1986 who are left-handed as a function of the year they were born. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@instructions"
    ]
   },
   "source": [
    "Add two new columns, one for birth year and one for mean left-handedness, then plot the mean as a function of birth year.\n",
    "- Create a column in `lefthanded_data` called `Birth_year`, which is equal to 1986 - `Age` (since the study was done in 1986).\n",
    "- Create a column in `lefthanded_data` called `Mean_lh` which is equal to the mean of the `Male` and `Female` columns.\n",
    "- Use the `.plot()` method to plot `Mean_lh` vs. `Birth_year`.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Helpful links:\n",
    "- [Creating a column in `pandas`](https://coderwall.com/p/dt4yja/adding-columns-to-a-pandas-dataframe)\n",
    "- matplotlib [tutorial](https://matplotlib.org/tutorials/introductory/pyplot.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@hint"
    ]
   },
   "source": [
    "You can create a new column called \"Integer_temp\" in the DataFrame `my_data` from an existing column called \"Temp\" like so:\n",
    "\n",
    "```python\n",
    "my_data[\"Integer_temp\"] = int(my_data[\"Temp\"])\n",
    "\n",
    "```\n",
    "\n",
    "You can calculate the mean of two columns row-wise by using the `.mean()` function and setting the parameter `axis = 1`. Try something like this:\n",
    "\n",
    "```python\n",
    "my_data[\"means\"] = my_data[[\"column_1\", \"column_2\"]].mean(axis = 1)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "@sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "# create a new column for birth year of each age\n",
    "# ... YOUR CODE FOR TASK 2 ...\n",
    "\n",
    "# create a new column for the average of male and female\n",
    "# ... YOUR CODE FOR TASK 2 ...\n",
    "\n",
    "# create a plot of the 'Mean_lh' column vs. 'Birth_year'\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(..., ..., ...) # plot 'Mean_lh' vs. 'Birth_year'\n",
    "ax.set_xlabel(...) # set the x label for the plot\n",
    "ax.set_ylabel(...) # set the y label for the plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": [
     "@solution"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7fd3eedcd198>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEKCAYAAAAfGVI8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xd81fX1+PHXyR5kDwKBDFbYM2wQFSduq1WrbR2ttdo9tWprl52/DvVbV6t17wFa0SpVkKFAIOwNWZCE7L3v+/fHvTeEzEuSO3LveT4eeeTez/3c+zkJ4Z77XuctxhiUUkr5Lj93B6CUUsq9NBEopZSP00SglFI+ThOBUkr5OE0ESinl4zQRKKWUj9NEoJRSPk4TgVJK+ThNBEop5eMC3B2AI+Lj401aWpq7w1BKqSElKyur1BiT0Nd5TksEIvIUcClw0hgztdNjPwT+DCQYY0r7eq20tDS2bt3qnECVUspLiUiuI+c5s2vo38BFnQ+KyGjgAiDPiddWSinlIKclAmPMOqC8m4f+CvwE0Gp3SinlAVw6WCwiVwDHjTE7XHldpZRSPXPZYLGIhAE/w9ot5Mj5twO3A6SkpDgxMqWU8m2ubBGMBdKBHSKSA4wCtolIUncnG2OeMMZkGmMyExL6HPRWSinVTy5rERhjdgGJ9vu2ZJDpyKwhpZRSzuO0FoGIvARsAjJEpEBEbnPWtZRSSvWf01oExpgb+ng8zVnXVkqpzlrbLKzMPkFZXRMtbYbWNkNESABfmp9CSKC/u8NzqyGxslgppQbqqQ3HePC9/V2OF1c3cs+KSW6IyHNoIlBKeb3aplYeW3uUpePjefSmOQT4CYH+ftz71i7+uf4Yl80YydTkKHeH6TZadE4p5fWe2ZhDeV0zPzh/AsOCAwgJ9MffT7jn4knEhAVx95s7aW2zuDtMt9FEoJTyatWNLTyx7ijnTkxkVkrMaY9FhQXyy8unsPt4NU9vyHFPgB5AE4FSyqs9vT6HqoYWvn/ehG4fXzEtifMmJfKXDw+SX17v4ug8gyYCpZTXqqpv4Z/rj3LB5OFMG9X9GICI8KsrpuIn8LO3dlFc3YjF4lul0HSwWCnltf65/ig1ja18r4fWgN3I6FB+evFEfr5yD/MfXENQgB+jokOZOCKC3145jZjwIBdF7B6aCJRSXqm8rpmn1h9jxbQkJo+M7PP8Ly9IZcLwCA6drKWgvJ78inpW7y5ifGIE3z+/90Qy1GnXkFLK6xhjuPetXTS3WXocG+hMRFgwJo4vL0jlnhWT+MeNc1g2IYGXNufR0o8ZRUVVjXz35e2U1jad8XNdTROBUsrrvLo1n9W7i/jRBRmMHx7R79f5ysJUTtY08cGeojN6njGG+97excrsE6zZV9zv67uKJgKllEewWAwbj5RizMAGao+W1PLAqr0sGhvH15eOGdBrLZuQSEpsGM9udGjHx3bv7Srio30nAdieVzmgGFxBE4FSyiO8nlXAl578nOz8/r9xNrda+O7L2QQH+vGXL87Ez08GFJO/n3DTghQ255Szv6jaoedU1bfwi1V7mJocyZJx8X3+PG0WQ1ZuOX/6YD83P72ZoqrGAcXcH5oIlFIe4e3s4wDsLXTsDbc7f/nwILuOV/H7q6eTFBUyKHF9MXM0wQF+PLvJsVbB71bvo6K+md9fPZ05qTEcKK6htqm1y3mNLW3c8+ZOMn/zIV94dBOPrT3KJwdKzrgbajBoIlBKuV1xdSObjpYBcLCopl+vsflYOY+vO8IN80Zz0dRu97vql+iwIC6fMZK3th2nqqGl13M/O1rGy1vy+dqSdKYmRzErJRpjYGdB11bB6t2FvLQ5n8Xj4nn4hllsu+98RkSFsCWnu63enUunjyrlg4wxfHKwhI2HS7nrnHFEhw3+PPnCqgZW7ypyqMzzOztOYAwMjwzmQPGZJ4LGljbufmMno2JCuf/Syf0NuUdfXZTGa1kFvJFVwK1L0skvr+fpDTms3l1IVGggI6NDGRkdwrqDpaTEhrWvW5g5OhqwjhMsGht/2muuPVBCXHgQD10/q70La05qDFtzKjDGIDKwbq0zoYlAKR/S2mbhP7sKefSTI+y3ffL+5EAJz942jxFRoYN2nY2HS/n2S9spq2umvK6ZH12Y0ev5q3acYFpyFFNGRvLBnqIzfiN8+H+HOFpax3O3zSMsaPDf1uyf7p/eeIwtOeV8sKcIPxHOnZiIxcDxygayciuoa2rlmVvnERpkTXzRYUGMiQ/vMk5gsRg+PVTK0vHxp41jzE2L5d2dhRyvbGBUTNig/xw90USglI/IKa3jK09tJq+8nnGJw/jztTNIjAjmzhe2cc2jm3j2tnmMTRg2oGsYY3h83VH++P5+xiQMY+boaB5be4TLZowkI6n7aZzHSuvYWVDFfZdMwk+El7fkU1rbTEJEsEPX3HuimsfXHuULs0exdLzz9jf/6sI0vvdKNtUNrXxj2Vi+ujCtyzhEm8Xg32mAemZKNOsOlp6W3PacqKasrpllGafHOyfVWhQvK7dCE4FSavA9uymXoqpGHv/yHM6fNLz9k+jLty/g5qc3c+1jm3j65rnMsHVn9CUrt4JvPLeVuPBgRseGkRIbRm5ZHWv2n+SS6SP44xem09Rq4by/rOXuN3fy+h2LurxJAqzKPoEIXDp9JEdKagE4WFzjUCJosxjufnMnUaGB3HeJczeXuWLmSBIjg5k5OrrHVkd3P9+s0dG8ue34aZ/y1x0qAeiSuCYmRTAsOIAtOeVcMTN5kH+CnulgsVI+wGIxrN5dyFkTErhwStJp3RFTk6N4/Y5FhAf7c8OTn/HvDcdoc6Do2lMbjtHUaiElLoz88npe2pzHukMl3HfJJB65YRbhwQHEhgdx/6WT2J5XyfOfdZ11Y4xh5Y7jLEiPIykqhAm2xV8HHBwwfnrDMXYWVPHA5VOcXg9IRFg0Nv6Mu57spa87ridYe6CEqcmRxA87PdkF+PsxKyWarTkVAw/4DGgiUMoHbM+vpLCqkUumdz+bJi0+nDfuWMSc1BgeeGcvVz+6kX29TOOsqGvmwz3FXDNnFE9+JZMPvn8We391Ibt/eSFfWzrmtP79K2cms3R8PH98fz8nKhtOe509J6o5WlLHFTNHAhA/LIjY8CAOOjBgvOdEFf/vvwdZPjGRS6ePcOTX4BYZSREEB/i1J4Lqxhay8ipYNqH7bqzM1FgOFNf0OUNpMGkiUMoHvLerkCB/P5ZPGt7jOYmRITx76zz+fv1MCsrrufTh9fzh/f3dtg7e2n6c5jYL180d3X5MRAgO6Do7SET47ZXTaDOGn6/cfVrdnpXZxwn0Fy6eOqL93AnDh/U5c+jDvcVc+9gmokID+fWVU106w+ZMBfr7MX1UFNn51k/5Gw+X0WYxLJuQ2O35c9NiMAa25bmuVaCJQCkvZ7EYVu8q5KwJ8USGBPZ6rohwxcxk1vxwGVfNSubRT47w8pa8084xxvDKlnxmjIpiYlLfVT0BUuLC+OH5GXy07ySZv/mIH766gw/3FvPOjkKWTUgkKuxUXBnDIzhYVNNtqQljDE+sO8Ltz21lXOIwVn5rMSOjB2+2k7PMSolh94lqmlstrD1YwrDgAGaldD8WMzMlGn8/IcuF3UOaCJQaIowxVNWfeXdBdkElJ6oaWTHN8e6T6LAg/nTNdOanx/LnDw5QWd/c/tiOgioOFNdw3dyUM4rja0vT+edXMlk+KZEP9xbx9We3UlTd2N4tZDchKYK65jaOd+pGam2zcPcbu3jwvf2smDqCV25fyPDIwVk97GwzR0fT3Gphb2E16w6WsHhcHIH+3b/9hgUFMGVkpEsXlmkiUGqI+M+uQub+9qP2mTWOem+ntVvovMk9dwt1R0R44PIpVDW08JcPD7Yff2VLHqGB/lw248z65UWE8yYP5y9fnEnW/efz3G3zuO+SSV1WAWfYBow7jxOszD7BK1vzueucsTx8w6z2ufpDgf3T/xtZBRyvbOixW8guMzWWHQWVNLeeefnr/tBEoNQQ8c6OEzS3WXjhs7y+T7axWAzv7Spk6fi+u4W6M2lEJF9ekMrzn+Wy90Q19c2tvLOjkBXTRhDRj9ezC/T3Y+n4BL62dEyXT8bj22cOnZ7w3s4+TkpsGD+6IGPAxeRcbURUKMMjg3llSz4AZ02I7/X8zLQYGlss7DlR5YrwNBEo5S6tbRaHZseAtYTCuoOliMDrWfk0NLd1e87/9hfT2mEwtj/dQp394PwMosOCeGDVHt7dWUhtUyvXzxvd9xP7KSo0kBFRIaf9bk7WNLLhcClXzBzp0QPDvZk1OobmNgtjE8L7XCyW2WFhmStoIlDKTV74PI8L/rrOof/sm46U0dDSxjeXjaW6sZV3d57ocs6fPjjArf/eyhce3cjhk9Y30fd2FhLoL2fcLdRRVFggP74wg8055fz2P/sYkxDe/kblLBOGR5y2luCdHYVYDC5dZDXYZtq6h87qYdpoR4mRIaTEhrlsnEATgVJusmqH9c38oTWH+jz3v3uLCQ/y5zvLxzM2IZwXPj+9e+hYaR3Pbsphfnos+RUNrHhoPY+vPcLq3UUsHZ9AVGj/u3HAWop5WnIUVQ0tfDFztNM/lWckRXC4pLa9dbMy+zhTkyMZlziwEhjutHBMHAAXTHasMmpm2qkCdM6miUApNyisarDVkwll7cGSXjcvsVgMa/YVsywjgZBAf26cn0p2fiW7j5/qP/7de/sI8vfj4S/N4oPvncU5GQn8bvV+jlc2DKhbyM7fT3jwqmnMT4/l2jmjBvx6fZkwPILmVgu55fUcLallZ0EVVw7h1gDAjNHRfP6z5SwcG+fQ+ZmpsZTVNZNTVu/kyDQRKOUWq3dZNx957KY5RIcF9toq2HW8ipM1TZxnWwz2hdmjCAn048XN1lbBxiOl/HdvMXeeM47EiBASIoJ57KY5/O26mVw8NYkLp/S/W6ijaaOieOUbC4kb5lgxuIFonzlUVMPbtlpEl80Y2cezPN+ZTHedmxZDRHAAeeWaCJTySv/ZVcjEpAimJkfxtSXp/G//SXYVdD9D5KN9xfj7CedkWKccRoUFctn0kby93bpRym/e3UdydCi3LUlvf46IcOWsZB69ac6AZve4y7jEYYjA/qIaVmYfZ9HYuCGzZmCwjEscRvYvLuixFMVg0kSglIvZu4Xs9XG+uiiNqNBAHvpf962CD/cWk5kac1pRtRsXpFLf3MbXn93K3sJqfnJRRp+bvwwloUH+pMaG8db24+SW1Q/pQeL+EpFuq5k6gyYCpVzM3i1k77uPCAnktiXpfLi3uMu88fzyevYX1XB+p1k/M0ZZN3HZfKycWSnRXO4F3SadTRgeQV55PUEBfoO69aTqShOBUi5m7xYa02ETmK8uSiMiJICH1xw+7dyP9hUDdCkWJyLcvCgNfz/h/ksnD9m59b2xb2Rz3qTEfi2GU47TRKCUC3XuFrKLCg3k1sXpvL+niDuey2pfB/DRvmLGJQ4jPT68y2tdM2cUm+45l9kpzp3T7y72gna+2C3karpDmVIu1LlbqKO7zhmHnwhPfnqU/+4t4qpZo/j8aDlfP2tMt68lIiRGeO8A6gVThvPYTdbd1JRzOa1FICJPichJEdnd4difRGS/iOwUkbdExLE98ZTyEt11C9kFBfjx3fPGs+4n53Dr4nTe2XGCVotpnzbqawL9rWMDQ62u0FDkzK6hfwMXdTr2ITDVGDMdOAjc48TrK+VReuoW6iw2PIj7Lp3Mxz8+m0dvnM3sHurWKzVYnNY1ZIxZJyJpnY79t8Pdz4BrnHV9pTxFc6uF17LyeXjNYfz9hEumOzbDJzk6lOQhsOmKGvrcOUZwK/BKTw+KyO3A7QApKWe2AYZSnqClzcLK7BP8fc1B8ssbmJ0Szd+un9ntwK9S7uSWRCAi9wKtwAs9nWOMeQJ4AiAzM9P5VZeUGiRHSmp5dUs+b2wroLS2manJkfzqlqmcPSHBK6d5qqHP5YlARG4GLgWWG1eU1VPKRXLL6vjxazvZnFOOv5+wfGIi188bzTkZiZoAlEfrMRGIyC6gxzdq24DvGRGRi4CfAMuMMc6vpKSUC92/cg/7Cqu5++KJXD072aundirv0luL4FLb97ts35+zfb/RkRcWkZeAs4F4ESkAfoF1llAw8KHtE9Jnxpg7zjBmpTzO+kOlrDtYwr0rJvU4718pT9VjIjDG5AKIyPnGmFkdHrpbRLYBd/f2wsaYG7o5/K9+RamUB7NYDL9bba0A+uWFqe4OR6kz5sg6AhGRxR3uLHLweUr5hHd2nmDPiWp+dOEEr6oAqnyHI4PFtwFPiUiU7X4l1qmfSvm8ptY2/vTBASaPiOSKGVoTRw1NfSYCY0wWMMOeCIwx3e+eoZQPem5TLgUVDTx/23QthaCGrD67eERkuIj8C3jZGFMlIpNF5DYXxKaUR6tqaOGRjw+zdHw8S8bHuzscpfrNkb7+fwMfAPZ18QeB7zkrIKWGijeyCqisb+GnF010dyhKDYgjiSDeGPMqYAEwxrQCbU6NSqkhYP3hUsYkhDM1Oarvk5XyYI4kgjoRicO2uExEFgA6TqB8WnOrhc+OlrF4rHYJqaHPkVlDPwBWAWNFZAOQgFYNVT4uO7+S+uY2Fo/TRKCGPkdmDW0TkWVABiDAAWNMi9MjU8qDrT9cip/AwjFx7g5FqQHrrdbQ1T08NEFEMMa86aSYlPJ4Gw6XMm1UNFFhuqm6Gvp6axFcZvueCCwC/me7fw6wEdBEoHxSTWML2fmV3LFMawop79BbraFbAETkv8BkY0yh7f4IrFNKlfJJnx8tp81idHxAeQ1HZg2NticBm2JAtwxTPmv94VJCAv2YnRLj7lCUGhSOzBpaIyIfAC/Z7l8HfOS8kJTybBsOlzI3LVYLzCmv4cisoW/ZBo6X2g49YYx5y7lhKeWZiqsbOXSylmvmjHJ3KEoNGoe2qrTNENLBYeXzNhwuBdDxAeVVHCk6d7WIHBKRKhGpFpEaEal2RXBKeZr1h0uJCQtk8ohId4ei1KBxpEXwR+AyY8w+ZwejlCczxrDhcCmLxsVryWnlVRyZNVSsSUApOFJSS3F1E0u0W0h5GUdaBFtF5BXgbaDJflBXFitf8+Ln+QCaCJTXcSQRRAL1wAUdjhl08Fj5kE1Hynh64zFunJ/C6Ngwd4ej1KByZProLa4IRClPVd3Ywo9e20FqbBj3XjLJ3eEoNej6TAQiEoJ1A/spQIj9uDFGN7BXPuGBVXsorGrg9W8uIizIoRnXSg0pjgwWPwckARcCa4FRQI0zg1LKU7y/u5A3tx3nrnPGaUkJ5bUcSQTjjDH3A3XGmGeAS4D5zg1LKfc7XtnAPW/uYlpyFN9ZPt7d4SjlNI60c+2b0FSKyFSgCGtpaqW8ksVieHFzHn9YvZ82Y/jrdTMI9HfkM5NSQ5MjieAJEYkB7se6ZeUw4OdOjUopNzl8spZ73tzJlpwKFo2N48GrppEWH+7usJRyKkdmDf3TdnMtoDtxKK+18XApNz+9hdAgf/50zXSumTMKEV1BrLyfI7OGgoEvAGkdzzfG/Mp5YSnlek98epSY8EDe/fZSEiKC3R2OUi7jSNfQSqAKyKLDymKlvElhVQPrDpZw59njNAkon+NIIhhljLnI6ZEo5UZvZBVgMXBtpu4zoHyPI1MhNorINKdHopSbWCyGV7cWsGBMLKlxOjCsfE+PLQIR2YW1plAAcIuIHMXaNSSAMcZMd02ISjnX5pxy8srr+d55ulZA+abeuoYudVkUSrnRq1vyiQgO4OKpI9wdilJu0WMiMMbkdj4mIrcbY55wbkhKuU51Ywvv7S7k6tmjCA3SzeiVbzrT5ZJ3OHqiiDwlIidFZHeHY7Ei8qFt68sPbQvVlHK6msYW7n1rFwseXMOrW/MxxgDw7o5CGlssfDFztJsjVMp9zjQRnMnqmn8DnWcb3Q2sMcaMB9bY7is1KFbtOMG0X3zAPW/uYl/hqW211x4s4cK/ruPFzXlEhATwk9d38qUnP+dYaR2vbM1nwvBhzBgV5cbIlXIvRxaUpRtjjtnuXtbNsW4ZY9aJSFqnw1cAZ9tuPwN8AvzU8XCV6tnzn+UiAm9tL+ClzXnMS4tlRHQIK7NPMDYhnDe+uYiZo6J5eUs+v1u9jwv/uo7mNgv3XTJJVxArn+ZIi+AN+w1jTIHt5uv9vN5wY0yh7XYRMLyfr6N80M6CSn746g6aWy1dHiusamBLTjlfWzqGz+5Zzr0rJlFY3cC7Owv55tlj+c93ljI7JQY/P+FL81NY84NlnD95OPHDgrlqVrIbfhqlPEdv00cnYt2MJkpEru7wUCQdNqjpL2OMERHTy/VvB24HSElJGejllBd4dWs+b2wr4KwJ8Vwx8/Q373d3FGIMXDZjJNFhQXz9rDHcuiSdhpY2hgV3/TNPjAzh/26cjTFGWwPK5/XWIsjAOoU0GmuXkP1rNvD1fl6vWERGANi+n+zpRGPME8aYTGNMZkJCQj8vp7zJ1pwKAJ7ekNPlsVU7TjAtOYr0DpVC/f2k2yTQkSYBpXofI1hkjLlFRH4+iAXmVgFfBX5v+75ykF5XebnqxhYOFNcwKiaU7PxKtudVMMu2Y9ix0jp2Ha/i3hW6n7BS/dFbi2CFWD8uXdmfFxaRl4BNQIaIFIjIbVgTwPkicgg4z3ZfqT5tz6vEGLj/0slEBAfw74057Y+tyj6BCFw6QxeEKdUfvbUI3gcqgGEiUo2ttASnSkxE9vbCxpgbenhoeX8CVb5ta045/n7CknHxXJs5mmc35fCzFZNIjAhm1Y7jzE2LZURUqLvDVGpI6rFFYIz5sTEmGviPMSbSGBPR8bsLY1SKrTkVTBoRQXhwAF9dlEqbMbzwWS57C6s5UlLH5TNGujtEpYYsR3You0JEUoHxxpiPRCQUCDDG1Dg/PKWgpc1Cdn4l1821rv5NjQtn+cREXvg8j5qmVgL8hBXTtFtIqf7qcx2BiHwd67qBx22HRgFvOzMopTraV1hNQ0sbmWmnKpLcsjidsrpmntmYw5Lx8cSGB7kxQqWGNkcWlN0FLAaqAYwxh4BEZwalVEf2aaOZqbHtxxaNjSNjeAQWg3YLKTVAjiSCJmNMs/2OiARgHTRWyiWycitIjg4lKerUOkYR4TvLx5MeH84FU5LcGJ1SQ58jW1WuFZGfAaEicj5wJ/COc8NSysoYw5acchaOjevy2CXTR3DJdB0bUGqgHGkR3A2UALuAbwDvAfc5Myil7AoqGjhZ00RmWmzfJyul+sWRWUMW4Enbl1IutTW3HIDMVN26QilncWTP4m7pnsXKFbbmVBARHMCE4RHuDkUpr6V7FiuPlpVbwazUGPz9tDicUs5yRnsWK+VKVQ3WQnOX6GIxpZzqTLeqVMplthwrxxiYk6bjA0o5kyPTR5VyKYvF8Nxnufzh/f3Ehgcxc3S0u0NSyqs5lAhs9YVSjDEHnByP8nFHS2r56Rs72ZJTwVkTEnjwqqmEBennFaWcyZHN6y8D/gwEAekiMhP4lTHmcmcHp3zLxwdOcsdzWQQH+PHna2fwhdnJuoOYUi7gyEetB4B5wCcAxphsEUl3YkzKBzW3Wnhg1R5Gx4bx4tfmkxg54G2xlVIOcmSwuMUYU9XpmNYaUoPqpc155JbVc++KSZoElHIxR1oEe0TkS4C/iIwHvgNsdG5YypfUNLbw9zWHWDAmlrMzEtwdjlI+x5EWwbeBKUAT8BLWctTfc2ZQyrc8se4o5XXN3HPxJB0TUMoNHKk1VA/ca/tSalAVVzfyz0+Pcen0EczQaaJKuYUjs4beoeuYQBWwFXjcGNPojMCUb/jbRwdptVj48YUZ7g5FKZ/lSNfQUaCWUxVIq4EaYAJakVQNwKHiGl7Zks+N81NJjQt3dzhK+SxHBosXGWPmdrj/johsMcbMFZE9zgpMebeaxha+9eJ2hgUH8O1zx7k7HKV8miMtgmEikmK/Y7s9zHa3ufunKNWzNovhuy9nc7ikln/cOIe4YcHuDkkpn+ZIi+CHwHoROQIIkA7cKSLhwDPODE55p9+v3sf/9p/k11dOZcn4eHeHo5TPc2TW0Hu29QMTbYcOdBgg/pvTIlNe6ZUteTz56TFuXpTGlxekujscpRSOVx8dD2QAIcAMEcEY86zzwlLeaPOxcu57ezdLx8dz3yWT3B2OUsrGkemjvwDOBiZj3bj+YmA9oIlAOayoqpE7X8hidEwYj3xpNgH+uhWGUp7Ckf+N1wDLgSJjzC3ADCDKqVEpr9LU2sY3X8iiobmNx788h6jQQHeHpJTqwJFE0GCMsQCtIhIJnARGOzcs5U1+/e5etudV8udrZzBeN6FXyuM4MkawVUSisS4ey8K6uGyTU6NSXuO1rfk8/1ke31g2hot172GlPJIjs4butN18TETeByKNMTudG5byBvsKq7n37d0sHhfHjy/QEhJKeao+u4ZEZI39tjEmxxizs+MxpXry8uY8AvyEh66fpYPDSnmwHlsEIhIChAHxIhKDdTEZQCSQ7ILY1BD3+bFy5qTG6MphpTxcb11D38C678BIrGMD9kRQDTzi5LjUEFdZ38z+ohouna7jAkp5uh4TgTHm78DfReTbxpiHXRiT8gJbcioAmJce5+ZIlFJ9cWSw+GERWQSkdTx/ICuLReT7wNew7nOwC7hF9zXwLpuPlREU4Mf0UbrkRClP58jK4ueAsUA20GY7bOjnymIRSca67/FkY0yDiLwKXA/8uz+vpzzT5mPlzBwdTUigv7tDUUr1wZF1BJlY37Q771I20OuGikgL1gHpE4P42srNapta2X2imjvPHuvuUJRSDnBkTt9uIGmwLmiMOQ78GcgDCoEqY8x/O58nIreLyFYR2VpSUjJYl1cukJVbQZvFMF/HB5QaEhxJBPHAXhH5QERW2b/6e0HbVNQrsO5rMBIIF5GbOp9njHnCGJNpjMlMSEjo7+WUG2w+VkaAnzA7VTejV2oocKRr6IFBvuZ5wDFjTAmAiLwJLAKeH+TrKDfZfKycqclRhAU5WuVcKeVOfbYIjDFrgRwg0HZ7C7BtANfMAxaISJiICNbKpvsG8HrKgzS2tLEjv4r56bHuDkUp5SBHSkx8HXiU3tlaAAAXcUlEQVQdeNx2KBl4u78XNMZ8bnu9bVinjvoBT/T39ZRn2Z5XSXObhXmaCJQaMhxpu98FzAM+BzDGHBKRxIFc1BjzC+AXA3kN5Xzb8yr4+5pD1De10dTaRlOrhVExofz1uplEhHS/p8DmY+WIQGaaJgKlhgpHBoubjDHN9jsiEoB1HYHyYk2tbXz/lWx2FlTh5wfRYUGMignl4wMl/Pi1nfQ0m3hzThmTkiJ18xmlhhBHWgRrReRnWOf9nw/cCbzj3LCUuz29IYecsnqeuXUeyyacmrX15Lqj/Pa9fTz56VFuP+v0dQLNrRayciu4fm6Kq8NVSg2AIy2Cu4ESrP3538C6b/F9zgxKudfJ6kYeXnOI8yYlnpYEAL62NJ0V05L4/er9bDxSetpju45X0dhi0YFipYYYR1oEocBTxpgnAUTE33as3pmBKff5w/sHaGkz3HfJ5C6PiQh/vGYGB4pq+PaL23n3O0uoqGth5Y7jrMo+gZ/AXE0ESg0pjrQI1mB947cLBT5yTjjK3bbnVfDGtgJuXZJOWnx4t+cMCw7g8S/PobGljXP/vJYVD33Kvz49xqQRkfzr5rnE6/4DSg0pjrQIQowxtfY7xphaEQlzYkzKTSwWwwPv7CUxIphvnTuu13PHJUbw0A2zeGZTLhdMHs6KaSOIDQ9yUaRKqcHkSCKoE5HZxphtACIyB2hwbljKGaoaWtiRX8nCsXEEdto6sqq+hb98eIAd+ZX8v2tnMCy47z+N5ZOGs3zScGeFq5RyEUcSwXeB10TkBNZdypKA65walY+oa2qlpKapxy6YwfbwmkP8c/0xEiOCuXF+KjfMH01kSCD/3pjDPz4+TE1TKzfMG81Vs3QnUqV8Sa+JQET8gCBgIpBhO3zAGNPi7MB8weNrj/Dkp8f47GfLXTLvfv3hUjKGRzAiOoS/fnSQRz4+RFRoIKW1zZyTkcBPLprIpBGRTo9DKeVZek0ExhiLiPyfMWYW1nLUahDlldfT0NLGB3uK+GLmaKdeq6y2if1FNfzoggl869zxHCut49lNOeSX13PbkjEsHKslo5XyVY50Da0RkS8Abw7y5jQ+72RNEwDv7Djh9ETw+bFyABaOjQcgPT6cX1w2xanXVEoNDY5MH/0G8BrQLCLVIlIjItVOjsspjpbU8tHeYneH0c6eCDYcLqXEdttZNh4pJTzIX/cQVkp14UgZ6ghjjJ8xJtAYE2m7PyQ7kv+5/hh3vriN1jaLu0MBoKSmiQVjYrEY+M9O5+7WufFIGXPTY7vMFlJKKUfKUIuI3CQi99vujxaRec4PbfCV1TbR3Goht9z9i6IbW9qoamhhybh4JiZFsGpH/xJBm8X0WADOrri6kaMldSzScQClVDccGSP4B2ABzgV+DdQC/wfMdWJcTlFRZ53sdLCohrEJw9wai70rKDEihMtnjuSP7x8gv7ye0bGOr9X71/pj/PrdvQD4CQT4+ZEeH87Kby0mJNC//bxNR8oAWDgmfhB/AqWUt3Ckn2C+MeYuoBHAGFOBdUrpkFNeb62mfaC4xs2RQEmtNREkRARz2fSRALxzBt1Dza0WHlt7hCkjI/nu8vHcdc44rps7mgPFNbyyJf+0czcdKSMyJIDJI4dkj55SyskcaRG02ArNGQARScDaQhhyKuqsieCgBySCk9WnEsHo2DDmpMawKvsEd57de2kHu/d2FVJS08SfrpnO2RnWfYKMMewvquaxtUe4YV4KQQHWPL/xaCkLxsTh7yfO+WGUUkOaIy2Ch4C3gEQR+S2wHnjQqVE5gcViqGywdg0dKHJ/IiipaQQgMdJaoO3yGSPZX1TjUJIyxvDUhmOMSQjnrPGnykSLCN8+dzyFVY28sa0AgPzyevLLG3SdgFKqR47MGnoB+AnwO6AQuNIY85qzAxtsNY2ttFkMEcEB5JTV09Ta5tZ4Smqa8BOIC7cmghXTRuAnsCq77+6hbXkV7Cyo4pZFafh1+pS/dHw8M0ZF8Y9PDtPSZmHTUev4wKKxOj6glOpej4lAREJE5Hsi8giwDHjcGPOIMWaf68IbPPbxgbnpsbRZDEdL6twaz8maJuKGBbd31yREBLN4XDyrdpzocxbQUxtyiAwJ4OrZo7o8Zm8V5Jc3sDL7BJuOlBEXHsSE4e4dHFdKea7eWgTPAJlYdya7GPizSyJyknLb+MCCMdZNU9w9TnCyponEiNPr9l84JYm88nqOlfacpE5UNvD+7iKun5dCeA8VQpdPSmTyiEj+8fFhNh4pZcHYOER0fEAp1b3eEsFkY8xNxpjHgWuAs1wUk1PYB4rnpMYQ4CduHycoqWkioVMiWDLO2n2zwTbdszvPbsrFGMNXFqb2eI61VTCOo6V1FFc36foBpVSveksE7RVGjTGtLojFqexdQ4kRIaTHh3tAi6CxS4sgNS6M5OhQNhwq7fY5Dc1tvLQ5jwsmJzEqpvf1BhdOSWJ8orU7aOEYTQRKqZ71Nn10RoeaQgKE2u4LYIZamYlKWyKICQ9iQlIEuwqq3BZLm8VQWttMYkTIacdFhMXj4vhgTzFtFtNluufb2cepamjh1iXpfV7Dz0/41RVTWb27kHQX7XeglBqaemwRGGP8bbWF7PWFAoZyraHyuhaC/P0ID/InY3gEeeX11De7p6FTUd9Mm8V06RoCWDwunqqGFvac6JqoXs8qYHziMOamxTh0nYVj4/jVFVN1fEAp1SufqUBWUddMTHggIsKE4REAHCqu7eNZzmFfTNa5awhOTfPccPj0cYK8snqyciu4anayvrErpQaVzySC8vpmYsKslTEykqyJwNmlJspqm8jOr+xy/GSnxWQdJUQEkzE8gg2HTx8neDv7OABXzNRtJJVSg8tnEkFFXTOx4dZEkBIbRnCAHwcHOHPoiXVHuOShT3t8/B+fHOH6JzbR0qnstb3gXMKwkO6exuJx8WzJKaexxbrozRjD29nHmZ8eS3J06IBiVkqpznwmEXRsEfj7CeMShw2oRWCM4ZmNuew5UU1VQ/dbOB8tqaWxxdJl8Zp9Q5ruWgQAi8fF0dRqYVtuBQC7jldxtKSOK3VTeaWUE/hMIqisbyEm/NQG8RnDIwY0RrAtr4LjlQ2Atf++O/Z9D/YXnb6hW0lNExEhAaeViu5oXnos/n7ChiPW7qG3th8nyN+PFVNH9DtepZTqiU8kgjaLobK+mdiwU9WzJyRFUFTdSFV995/m+9KxJlBuedeVwG0WQ0G5NVF0XrzW3WKyjiJCApk5Opr1h8tobbPwzo5Czp2YSFRYYI/PUUqp/vKJRFDd0ILFWNcQ2GXYZg4dPHnm3UOtbRbe3VnI2RnWyp+53bQIiqobabaNDXROBN0tJuts8dg4dhVUsnp3EaW1TVw5a+QZx6mUUo7wiURgX1Uc2yERjLcVYetPqYkNR8ooq2vm+rkpxA8LJresa4vAfix+WDD7uySCpi6LyTpbPC4ei4Hf/GcvkSEB7XsOKKXUYPOJRGCvMxTToWsoOTqU8CD/fpWaWJV9goiQAM7OSCAtLqzbFkG+bXzg/MnDOV7ZQHXjqS6ovrqGAGalxBAa6E9xdROXTB/R43iCUkoNlE8kgvJuEoGIMCEp4oxbBI0tbXywp4iLpyYREuhPSlwYeeVdE0FuWT0BfsI5tu4j+1TV2qZW6pvb+uwaCgrwY166tVKqrh1QSjmTWxKBiESLyOsisl9E9onIQmder9I2INxx1hDAlJGRbM2t4I7nsvjkwEnaLKf2ASiubuS9XYW8v7votP0BPt5/ktqmVi6fYX1zTo0Np6i6sX3Ov11ueT3JMaFMSY4CaO8eOlltXUzWV4sA4IZ5KVw4ZTjz0mLP9EdWSimHObJnsTP8HXjfGHONiAQBvZfSHKDuxggAfnh+BmFBAbyeVcD7e4pIjg5lxugoduRXtU8NBVg+MZE/XjOduGHBrMw+Qfyw4PatH1PjwjAGCirqGZcY0f6cvLJ6UmLDGBkVQkRIQPsUUvtisr7GCAAumprERVOTBvbDK6VUH1yeCEQkCuveBjcDGGOagWZnXrOirpngAD9CO/Wzx4QH8bMVk/jhBRP4cG8xL2/OZ2dBFTNTorl1STpzUmPYllvB71fv58K/fcovL5/C/w6c5Mb5Ke2VQVPirDkst6xTIiivZ8boEYgIGcNPdUH1tZhMKaVczR0tgnSgBHhaRGYAWcB3jTFO2zuy3FZeoqdibcEB/lw6fSSXTu86RXPm6GgWjo3juy9v564XtwGn99mnxloTQU6HAeOq+haqGlpIjbWWf544IoKV2dYtKE+2l5fQRKCU8gzuGCMIAGYDjxpjZgF1wN2dTxKR20Vkq4hsLSkpGdAFK+qbiQ4L6vvEHkwaEcmqby3h1sXpXDQliRmjotofiw0PIiI4gLwOU0jtC8zsrYWMpEhqGlsprGqkpKaJIH8/onVxmFLKQ7ijRVAAFBhjPrfdf51uEoEx5gngCYDMzMzed3Pvg7VFMLA33pBAf35+2eQux0WElLiw9nIScGqBWYqttTDRVu10f1E1J2saSYgI1lLSSimP4fIWgTGmCMgXkQzboeXAXmdes7K+5bSpo4MtNS7stHpD9umk9kRg3/9gf1ENJTVNxDswY0gppVzFXesIvg28ICI7gZnAg868WHl9c5cZQ4MpJTac/Ir69umneWX1xA8LJjzY2uCKCg1kZFQIB2yJoK81BEop5UpumT5qjMkGMl1xrdY2C1UNzm8RtLQZCqsaGBUTRm55Halxp8+InTgikgNFNZysaWJOqmNbTSqllCt4/criqoYWjOm6hmAw2WcO2ccG7GsIOspIiuDwyVrK65odWkymlFKu4vWJoMK2mMyZs3RS463TRHPL6mlqbaOwurFLIpiYFEGrrevIkcVkSinlKl6fCMrrrOUlnNkiSIoMIcjfj9zyOvLLGzCGLl1D9n2SoftN65VSyl28PhHYWwTOHCPw9xNGxYaSV1bfXnW0cyIYEz+MQH/rlFHtGlJKeRLvTwR13dcZGmypsdZy1PZ9CEZ36hoKCvBjbIJ1DwQtL6GU8iRenwjKXdAiAEiNCyevvJ7c8nrCgvy7LSFh7x6K1/ISSikP4q7qoy5TUddMaKA/oUHO3dglJTaM2qZWtudVkhIb1u3K4evmjiYpKoRAf6/Pv0qpIcTrE0F5XQsxLqjrYx8T2FlQyXmThnd7zqKx8SwaG+/0WJRS6kx4/UfTivrm0zatd5bUOOsUUouhy9RRpZTyZD6RCJw9UAwwOjYUe29Q5xlDSinlybw/EdQ1O32gGKx7GoyItC4US7G1DpRSaijw+kRg35TGFez7D6Rq15BSagjx6kTQ0mahurHVZZvApMWF4yeQHBPqkusppdRg8OpZQ5X1zi8v0ZF9n2OdHqqUGkq8OhG4orxERxOGR7RvQqOUUkOFV390dVV5CaWUGsq8OxG4uEWglFJDkVcnAleUoFZKqaHOqxOBKzalUUqpoc6rE0F5XTNhQf6EBDq34JxSSg1lXp0IJgwfxqXTR7g7DKWU8mhePX30urkpXDc3xd1hKKWUR/PqFoFSSqm+aSJQSikfp4lAKaV8nCYCpZTycZoIlFLKx2kiUEopH6eJQCmlfJwmAqWU8nFijHF3DH0SkRIgt59PjwdKBzGcwabxDYzGNzAa38B5coypxpiEvk4aEolgIERkqzEm091x9ETjGxiNb2A0voEbCjH2RbuGlFLKx2kiUEopH+cLieAJdwfQB41vYDS+gdH4Bm4oxNgrrx8jUEop1TtfaBEopZTqxZBMBCLylIicFJHdHY7NEJFNIrJLRN4RkcgOj90jIodF5ICIXNjh+Bzb+YdF5CEREVfHJyJxIvKxiNSKyCOdXscT4jtfRLJsx7NE5FwPi2+eiGTbvnaIyFWeFF+Hx1Ns/8Y/8qT4RCRNRBo6/A4f86T4bI9Ntz22x/Z4iKfEJyI3dvjdZYuIRURmOjM+pzDGDLkv4CxgNrC7w7EtwDLb7VuBX9tuTwZ2AMFAOnAE8Lc9thlYAAiwGrjYDfGFA0uAO4BHOr2OJ8Q3Cxhpuz0VOO5h8YUBAbbbI4CTHe67Pb4Oj78OvAb8yMN+f2kdz/PAv78AYCcww3Y/Dg/6/9vpedOAI87+/Tnjy+0BDOAfK63TP1QVp8Y8RgN7bbfvAe7pcN4HwELbm8b+DsdvAB53dXwdHr+ZDonA0+KzHRegHGtS9cT40oFi25uHx8QHXAn8CXgAWyLwlPg6n+dpf3/ACuB5T42v03MeBH7rivgG+2tIdg31YA9whe32tVj/sQCSgfwO5xXYjiXbbnc+7ur4euKJ8X0B2GaMafKk+ERkvojsAXYBdxhjWj0lPhEZBvwU+GWn8z0iPpt0W7fGWhFZ6mHxTQCMiHwgIttE5CceFl9H1wEv2W67Or4B8aZEcCtwp4hkARFAs5vj6WxIxyciU4A/AN9wQ2zQS3zGmM+NMVOAucA99j5kD4nvAeCvxphaN8TUUU/xFQIpxpiZwA+AFzuPb7g5vgCsXac32r5fJSLLPSg+wPphBKg3xuzu7smezms2rzfG7AcuABCRCcAltoeOc3r2HmU7dtx2u/NxV8fXE4+JT0RGAW8BXzHGHPG0+Dqcs09EarGNZXhIfPOBa0Tkj0A0YBGRRuANT4jP1rprst3OEpEjWD+Fe8rvrwBYZ4wptT32Htb+++c9JD676znVGgAX//4GymtaBCKSaPvuB9wH2Gc/rAKuF5FgEUkHxgObjTGFQLWILLCN5n8FWOmG+LrlKfGJSDTwH+BuY8wGD4wvXUQCbLdTgYlAjqfEZ4xZaoxJM8akAX8DHjTGPOIp8YlIgoj4226Pwfr/46inxId1TG+aiITZ/p2XYe2f95T47Me+CLxsP+bq+AbM3YMU/RzIeQlrk7YF6yeG24DvAgdtX7/HNrBjO/9erLOFDtBh5B7IBHbbHnuk43NcHF8O1kHYWtv5kz0lPqx/9HVAdoevRA+K78tY+2+zgW3AlZ7279vheQ9w+qwht8eHddyn4+/vMk+Kz3b+TbYYdwN/9MD4zgY+6+Z1nBKfM750ZbFSSvk4r+kaUkop1T+aCJRSysdpIlBKKR+niUAppXycJgKllPJxmgjUkCdW60Xk4g7HrhWR9110/eEiskVEtovIok6PFdjWYnR+zl0icmMPr3e1iEzscH+9vaKlUs7gNSuLle8yxhgRuQN4TUQ+xvp3/SBw0UBeV0QCjLVuUV/OB7KMMXc4+trGmP/r6ZrA1YAF2O/o6yk1ELqOQHkNWxmHOqylvWuMMb8Wka8CdwFBwEbgW8YYi4g8gbVUQSjwijHmV7bXKMBavuBCrKuAX+vw+unAU1hLIRcDtwBJwJu21zkOzDPGNHd4TgHwAtYqmvXADcaYoyLyG6DUGPM3EVmPtczxUqyrT7+PtdplFdbKpc8D64FzgSjgFmPMxkH95Smfpi0C5U1+iXV1bDOQKSJTgauARcaYVtub//XAi1hLZpTbPoF/LCKvG2P22l7npDFmVjev/w/gn8aYF0TkduBvxphrRORXwFRjzPd6iKvcGDNNRG4F/oL1zb0zf2NMJoCIZACvG2Pett0H64e2eSJyOfBzBtjaUaojTQTKaxhj6kTkFaDWGNMkIudhrUi61fZmGsqpkuQ3iMhtWP8PjMS6gZE9EbzSwyXmA5fabj8L/NrB0OzFyF7AWp6gOz1d0+5N2/csrLXylRo0mgiUt7HYvsC6kc5Txpj7O54gIuOx1o6ZZ4ypFJHngY6lq+sGOSZH+l/7umaT7Xsb+v9WDTKdNaS82UfAF0UkHtr3h04BIoEarNUhR2AdD3DEZ1irTIK1ENo6B593ne37DcCG3k60qcFa814pl9BPFsprGWN2icgvgY9spYJbsO4NvRVrN9B+IBfH3pzBOuj8lIjcw6nBYkfEi8hOoAFrMujLS8DjIvJDuh9PUGpQ6awhpZTycdo1pJRSPk4TgVJK+ThNBEop5eM0ESillI/TRKCUUj5OE4FSSvk4TQRKKeXjNBEopZSP+/9qQ4+emLG2nwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fd3eef589b0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create a new column for birth year of each age\n",
    "lefthanded_data['Birth_year'] = 1986 - lefthanded_data['Age'] # the study was done in 1986\n",
    "\n",
    "# create a new column for the average of male and female\n",
    "lefthanded_data['Mean_lh'] = lefthanded_data[['Female', 'Male']].mean(axis = 1)\n",
    "\n",
    "# create a plot of 'Mean_lh' vs. 'Birth_year'\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot('Birth_year', 'Mean_lh', data = lefthanded_data)\n",
    "ax.set_xlabel(\"Year of birth\")\n",
    "ax.set_ylabel(\"Percentage left-handed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": [
     "@tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 5, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_new_columns\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_birth_year_column\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_mean_lh_column\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_plot_contents\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_plot_labels\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "5/5 tests passed\n"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "def test_new_columns():\n",
    "    assert 'Birth_year' and 'Mean_lh' in lefthanded_data.columns, \\\n",
    "    'Did you create two new columns called \"Birth_year\" and \"Mean_lh\"?'\n",
    "    \n",
    "def test_birth_year_column():\n",
    "    import numpy as np\n",
    "    assert np.all(lefthanded_data[\"Birth_year\"] >= 1900), \\\n",
    "    'The values in the \"Birth_year\" column should be years >= 1900.'\n",
    "    \n",
    "def test_mean_lh_column():\n",
    "    import numpy as np\n",
    "    assert not np.any(np.isnan(lefthanded_data[\"Mean_lh\"])), \\\n",
    "    'Make sure you calculate the mean lefthandedness for each row of the DataFrame.'\n",
    "\n",
    "def test_plot_contents():\n",
    "    assert (len(ax.lines) == 1), \\\n",
    "    'Did you plot the mean lefthandedness data?'\n",
    "    \n",
    "def test_plot_labels():\n",
    "    assert ax.get_xlabel() != '' and ax.get_ylabel() != '', \\\n",
    "    'Please add x and y labels to your plot.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "type:NotebookTask"
    ]
   },
   "source": [
    "## 3. Applying Bayes' rule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@context"
    ]
   },
   "source": [
    "The probability of dying at a certain age given that you're left-handed is **not** equal to the probability of being left-handed given that you died at a certain age. This inequality is why we need **Bayes' theorem**, a statement about conditional probability which allows us to update our beliefs after seeing evidence. \n",
    "\n",
    "We want to calculate the probability of dying at age A given that you're left-handed. Let's write this in shorthand as P(A | LH). We also want the same quantity for right-handers: P(A | RH). \n",
    "\n",
    "Here's Bayes' theorem for the two events we care about: left-handedness (LH) and dying at age A.\n",
    "\n",
    "$$P(A | LH) = \\frac{P(LH|A) P(A)}{P(LH)}$$\n",
    "\n",
    "P(LH | A) is the probability that you are left-handed *given that* you died at age A. P(A) is the overall probability of dying at age A, and P(LH) is the overall probability of being left-handed. We will now calculate each of these three quantities, beginning with P(LH | A).\n",
    "\n",
    "To calculate P(LH | A) for ages that might fall outside the original data, we will need to extrapolate the data to earlier and later years. Since the rates flatten out in the early 1900s and late 1900s, we'll use a few points at each end and take the mean to extrapolate the rates on each end. The number of points used for this is arbitrary, but we'll pick 10 since the data looks flat-ish until about 1910. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@instructions"
    ]
   },
   "source": [
    "Create a function that will return P(LH | A) for particular ages of death in a given study year.\n",
    "\n",
    "- Import the `numpy` package aliased as `np`.\n",
    "- Use the last ten `Mean_lh` data points to get an average rate for the early 1900s. Name the resulting DataFrame `early_1900s_rate`.\n",
    "- Use the first ten `Mean_lh` data points to get an average rate for the late 1900s. Name the resulting DataFrame `late_1900s_rate`.\n",
    "- For the early 1900s ages, fill in `P_return` with the appropriate left-handedness rates for `ages_of_death`. That is, input `early_1900s_rate` as a fraction, i.e., divide by 100.\n",
    "- For the late 1900s ages, fill in `P_return` with the appropriate left-handedness rates for `ages_of_death`. That is, input `late_1900s_rate` as a fraction, i.e., divide by 100.\n",
    "\n",
    "<hr>\n",
    "\n",
    "When calculating `early_1900s_rate` and `late_1900s_rate`, remember that because the original data was from youngest age to oldest age, that means that the data is organized from latest birth year to earliest birth year. You will use the first ten `Mean_lh` data points to get an average rate for the late 1900s and the last ten for the early 1900s. \n",
    "\n",
    "Helpful links:\n",
    "- [Python functions](https://www.w3schools.com/python/python_functions.asp)\n",
    "- [Conditional probability](https://en.wikipedia.org/wiki/Conditional_probability)\n",
    "- [numpy array subsetting and indexing](https://docs.scipy.org/doc/numpy-1.10.0/user/basics.indexing.html)\n",
    "- numpy `logical_and()` [documentation](https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.logical_and.html)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@hint"
    ]
   },
   "source": [
    "You can get the mean of the last ten rows of the \"column\" column in `my_data` like so:\n",
    "\n",
    "```python\n",
    "last_ten_mean = my_data[\"column\"][-10:].mean()\n",
    "```\n",
    "\n",
    "For using array indexing to fill in `P_return`, since `ages_of_death` includes some ages that are older than the oldest age represented in `lefthanded_data`, `P_return` can be filled in with `early_1900s_rate` for the correct ages like this:\n",
    "\n",
    "```python\n",
    "P_return[ages_of_death > oldest_age] = early_1900s_rate / 100\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "@sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "# import library\n",
    "# ... YOUR CODE FOR TASK 3 ...\n",
    "\n",
    "# create a function for P(LH | A)\n",
    "def P_lh_given_A(ages_of_death, study_year = 1990):\n",
    "    \"\"\" P(Left-handed | ages of death), calculated based on the reported rates of left-handedness.\n",
    "    Inputs: numpy array of ages of death, study_year\n",
    "    Returns: probability of left-handedness given that subjects died in `study_year` at ages `ages_of_death` \"\"\"\n",
    "    \n",
    "    # Use the mean of the 10 last and 10 first points for left-handedness rates before and after the start \n",
    "    early_1900s_rate = ... \n",
    "    late_1900s_rate = ...\n",
    "    middle_rates = lefthanded_data.loc[lefthanded_data['Birth_year'].isin(study_year - ages_of_death)]['Mean_lh']\n",
    "    youngest_age = study_year - 1986 + 10 # the youngest age is 10\n",
    "    oldest_age = study_year - 1986 + 86 # the oldest age is 86\n",
    "    \n",
    "    P_return = np.zeros(ages_of_death.shape) # create an empty array to store the results\n",
    "    # extract rate of left-handedness for people of ages 'ages_of_death'\n",
    "    P_return[ages_of_death > oldest_age] = ...\n",
    "    P_return[ages_of_death < youngest_age] = ...\n",
    "    P_return[np.logical_and((ages_of_death <= oldest_age), (ages_of_death >= youngest_age))] = middle_rates / 100\n",
    "    \n",
    "    return P_return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": [
     "@solution"
    ]
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# create a function for P(LH | A)\n",
    "def P_lh_given_A(ages_of_death, study_year = 1990):\n",
    "    \"\"\" P(Left-handed | age of death), calculated based on the reported rates of left-handedness.\n",
    "    Inputs: age of death, study_year\n",
    "    Returns: probability of left-handedness given that a subject died in `study_year` at age `age_of_death` \"\"\"\n",
    "    \n",
    "    # Use the mean of the 10 neighbouring points for rates before and after the start \n",
    "    early_1900s_rate = lefthanded_data['Mean_lh'][-10:].mean()\n",
    "    late_1900s_rate = lefthanded_data['Mean_lh'][:10].mean()\n",
    "    middle_rates = lefthanded_data.loc[lefthanded_data['Birth_year'].isin(study_year - ages_of_death)]['Mean_lh']\n",
    "    \n",
    "    youngest_age = study_year - 1986 + 10 # the youngest age in the NatGeo dataset is 10\n",
    "    oldest_age = study_year - 1986 + 86 # the oldest age in the NatGeo dataset is 86\n",
    "    \n",
    "    P_return = np.zeros(ages_of_death.shape)  # create an empty array to store the results\n",
    "    # extract rate of left-handedness for people of age age_of_death\n",
    "    P_return[ages_of_death > oldest_age] = early_1900s_rate / 100\n",
    "    P_return[ages_of_death < youngest_age] = late_1900s_rate / 100\n",
    "    P_return[np.logical_and((ages_of_death <= oldest_age), (ages_of_death >= youngest_age))] = middle_rates / 100\n",
    " \n",
    "    return P_return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": [
     "@tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 5, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_output_type\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_late_1900s_rate\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_early_1900s_rate\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_middle_rate\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_middle_rates_are_different\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "5/5 tests passed\n"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "def test_output_type():\n",
    "    test_input = np.array([80])\n",
    "    assert (type(P_lh_given_A(test_input)) == float or \n",
    "            type(P_lh_given_A(test_input)) == np.float64 or \n",
    "            type(P_lh_given_A(test_input)) == np.ndarray), \\\n",
    "    'Does the function P_lh_given_A return a number?'\n",
    "\n",
    "def test_late_1900s_rate():\n",
    "    assert round(float(P_lh_given_A(np.array([10]))), 2) == 0.13, \\\n",
    "    'Did you calculate a left-handedness probability for the late 1900s?'\n",
    "\n",
    "def test_early_1900s_rate():\n",
    "    assert round(float(P_lh_given_A(np.array([95]))), 2) == 0.06, \\\n",
    "    'Did you calculate a left-handedness probability for the early 1900s?'\n",
    "\n",
    "def test_middle_rate():\n",
    "    assert P_lh_given_A(np.array([80])) > 0.06 and P_lh_given_A(np.array([80])) < 0.13, \\\n",
    "    'Make sure that P_lh_given_A returns the correct left-handedness rate as a fraction (< 1).'\n",
    "    \n",
    "def test_middle_rates_are_different():\n",
    "    assert np.any(P_lh_given_A(np.array([20])) != P_lh_given_A(np.array([50]))), \\\n",
    "    'P_lh_given_A should return different rates for different ages between youngest_age and oldest_age.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "type:NotebookTask"
    ]
   },
   "source": [
    "## 4. When do people normally die?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@context"
    ]
   },
   "source": [
    "To estimate the probability of living to an age A, we can use data that gives the number of people who died in a given year and how old they were to create a distribution of ages of death. If we normalize the numbers to the total number of people who died, we can think of this data as a probability distribution that gives the probability of dying at age A. The data we'll use for this is from the entire US for the year 1999 - the closest I could find for the time range we're interested in. \n",
    "\n",
    "In this block, we'll load in the death distribution data and plot it. The first column is the age, and the other columns are the number of people who died at that age. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@instructions"
    ]
   },
   "source": [
    "Load death distribution data for the United States and plot it.\n",
    "- Load death distribution data in the provided `data_url_2` into `death_distribution_data`, setting `sep = '\\t'` and `skiprows=[1]` to account for the dataset's format.\n",
    "- Drop the NaN values from the `Both Sexes` column.\n",
    "- Use the `.plot()` method to plot the number of people who died as a function of their age.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Helpful links:\n",
    "- pandas `read_csv()` function [documentation](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html)\n",
    "- pandas `dropna()` [documentation](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.dropna.html)\n",
    "- matplotlib [tutorial](https://matplotlib.org/tutorials/introductory/pyplot.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@hint"
    ]
   },
   "source": [
    "You can read `https://data_url.csv` into a DataFrame named `my_data` like this after importing the `pandas` library:\n",
    "\n",
    "```python\n",
    "import pandas as pd\n",
    "my_data = pd.read_csv(\"https://data_url.csv\")\n",
    "```\n",
    "\n",
    "You can drop `NaN` values in just one column of a DataFrame by using the `subset()` argument like this:\n",
    "\n",
    "```python\n",
    "my_data = my_data.dropna(subset = [\"column_name\"])\n",
    "```\n",
    "\n",
    "You can plot columns from a `pandas` DataFrame like this:\n",
    "\n",
    "```python\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(\"x_column\", \"y_column\", data = my_data, marker = 'o')\n",
    "ax.set_xlabel(\"Label for the x axis of the plot\")\n",
    "ax.set_ylabel(\"Label for the y axis of the plot\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "@sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "# Death distribution data for the United States in 1999\n",
    "data_url_2 = \"https://gist.githubusercontent.com/mbonsma/2f4076aab6820ca1807f4e29f75f18ec/raw/62f3ec07514c7e31f5979beeca86f19991540796/cdc_vs00199_table310.tsv\"\n",
    "\n",
    "# load death distribution data\n",
    "# ... YOUR CODE FOR TASK 4 ...\n",
    "\n",
    "# drop NaN values from the `Both Sexes` column\n",
    "# ... YOUR CODE FOR TASK 4 ...\n",
    "\n",
    "# plot number of people who died as a function of age\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(..., ..., data = ..., marker='o') # plot 'Both Sexes' vs. 'Age'\n",
    "ax.set_xlabel(...) \n",
    "ax.set_ylabel(...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": [
     "@solution"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7fd3eed0eb00>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fd3eed807b8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Death distribution data for the United States in 1999\n",
    "data_url_2 = \"https://gist.githubusercontent.com/mbonsma/2f4076aab6820ca1807f4e29f75f18ec/raw/62f3ec07514c7e31f5979beeca86f19991540796/cdc_vs00199_table310.tsv\"\n",
    "\n",
    "# load death distribution data\n",
    "death_distribution_data = pd.read_csv(data_url_2, sep = '\\t', skiprows=[1])\n",
    "\n",
    "# drop NaN values from the `Both Sexes` column\n",
    "death_distribution_data = death_distribution_data.dropna(subset = [\"Both Sexes\"]) # drop NaN from'Both Sexes' column\n",
    "\n",
    "# plot number of people who died as a function of age\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot('Age', 'Both Sexes', data = death_distribution_data, marker='o')\n",
    "ax.set_xlabel(\"Age\")\n",
    "ax.set_ylabel(\"Number of people who died\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": [
     "@tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 5, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_skiprows\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_data_shape\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_plot_contents\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_plot_dimensions\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_plot_labels\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "5/5 tests passed\n"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "def test_skiprows(): \n",
    "    assert death_distribution_data.loc[0][\"Age\"] == 0, \\\n",
    "    'Make sure to include `skiprows=[1]` as an argument in `pd.read_csv`.'\n",
    "    \n",
    "def test_data_shape(): # this will also test if the dropna worked\n",
    "    assert (death_distribution_data.shape == (120, 4)), \\\n",
    "    'Make sure you drop NaN values in the \"Both Sexes\" column only. The resulting DataFrame should have 120 rows.'\n",
    "    \n",
    "def test_plot_contents():\n",
    "    assert (len(ax.lines) == 1), \\\n",
    "    'Did you plot the death distribution data?'\n",
    "    \n",
    "def test_plot_dimensions():\n",
    "    assert ((ax.get_xticks()[-1] < 200) and (ax.get_yticks()[-1] > 200)), \\\n",
    "    'Did you plot \"Both Sexes\" vs. \"Age\"?'\n",
    "    \n",
    "def test_plot_labels():\n",
    "    assert ax.get_xlabel() != '' and ax.get_ylabel() != '', \\\n",
    "    'Please add x and y labels to your plot.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "type:NotebookTask"
    ]
   },
   "source": [
    "## 5. The overall probability of left-handedness"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@context"
    ]
   },
   "source": [
    "In the previous code block we loaded data to give us P(A), and now we need P(LH). P(LH) is the probability that a person who died in our particular study year is left-handed, assuming we know nothing else about them. This is the average left-handedness in the population of deceased people, and we can calculate it by summing up all of the left-handedness probabilities for each age, weighted with the number of deceased people at each age, then divided by the total number of deceased people to get a probability. In equation form, this is what we're calculating, where N(A) is the number of people who died at age A (given by the dataframe `death_distribution_data`):\n",
    "\n",
    "<img src=\"https://i.imgur.com/gBIWykY.png\" alt=\"equation\" width=\"220\"/>\n",
    "\n",
    "<!--- $$P(LH) = \\frac{\\sum_{\\text{A}} P(LH | A) N(A)}{\\sum_{\\text{A}} N(A)}$$ -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@instructions"
    ]
   },
   "source": [
    "Create a function called `P_lh()` which calculates the overall probability of left-handedness in the population for a given study year.\n",
    "- Create a series, `p_list`, by multiplying the number of dead people in the `Both Sexes` column with the probability of their being lefthanded using `P_lh_given_A()`. \n",
    "- Set the variable `p` equal to the sum of that series.\n",
    "- Divide `p` by the total number of dead people by summing `death_distribution_data` over the `Both Sexes` column. Return result from the function.\n",
    "\n",
    "<hr>\n",
    "\n",
    "P(LH | A) was defined in Task 3. N(A) is the value of `Both Sexes` in the `death_distribution_data` DataFrame where the `Age` column is equal to A. The denominator is total number of dead people, which you can get by summing over the entire dataframe in the `Both Sexes` column. \n",
    "\n",
    "Helpful links:\n",
    "- [Python functions](https://www.w3schools.com/python/python_functions.asp) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@hint"
    ]
   },
   "source": [
    "You can calculate the numerator (P(LH | A) N(A)) in one line by multiplying the \"Both Sexes\" column of `death_distribution_data` by `P_lh_given_A` for all the ages in `death_distribution_data['Age']`. Try something like this:\n",
    "\n",
    "```python\n",
    "p_list = death_distribution_data['Both Sexes']*P_lh_given_A(death_distribution_data['Age'], study_year)\n",
    "```\n",
    "\n",
    "To normalize P(LH | A) N(A) by the total number of deceased people (\\sum_A N(A)), try this:\n",
    "\n",
    "```python\n",
    "p/np.sum(death_distribution_data['Both Sexes'])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "@sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "def P_lh(death_distribution_data, study_year = 1990): # sum over P_lh for each age group\n",
    "    \"\"\" Overall probability of being left-handed if you died in the study year\n",
    "    Input: dataframe of death distribution data, study year\n",
    "    Output: P(LH), a single floating point number \"\"\"\n",
    "    p_list = ... # multiply number of dead people by P_lh_given_A\n",
    "    p = ... # calculate the sum of p_list\n",
    "    return ... # normalize to total number of people (sum of death_distribution_data['Both Sexes'])\n",
    "\n",
    "print(P_lh(death_distribution_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": [
     "@solution"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.07766387615350638\n"
     ]
    }
   ],
   "source": [
    "def P_lh(death_distribution_data, study_year = 1990): # sum over P_lh for each age group\n",
    "    \"\"\" Overall probability of being left-handed if you died in the study year\n",
    "    P_lh = P(LH | Age of death) P(Age of death) + P(LH | not A) P(not A) = sum over ages \n",
    "    Input: dataframe of death distribution data\n",
    "    Output: P(LH), a single floating point number \"\"\"\n",
    "    p_list = death_distribution_data['Both Sexes']*P_lh_given_A(death_distribution_data['Age'], study_year)\n",
    "    p = np.sum(p_list)\n",
    "    return p/np.sum(death_distribution_data['Both Sexes']) # normalize to total number of people in distribution\n",
    "\n",
    "print(P_lh(death_distribution_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": [
     "@tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 3, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_output_type\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_study_year\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_P_lh\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "3/3 tests passed\n"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "def test_output_type():\n",
    "    assert type(P_lh(death_distribution_data)) == np.float64 or type(P_lh(death_distribution_data)) == float, \\\n",
    "    'Have you defined a function called P_lh that returns the overall probability of left-handedness?'\n",
    "\n",
    "def test_study_year():\n",
    "    assert round(P_lh(death_distribution_data, 2018), 2) == 0.11, \\\n",
    "    'Make sure to include `study_year` as the second argument for the function P_lh()'\n",
    "\n",
    "def test_P_lh():\n",
    "    assert round(P_lh(death_distribution_data), 2) == 0.08, \\\n",
    "    'The overall probability of left-handedness should be approximately 0.08.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "type:NotebookTask"
    ]
   },
   "source": [
    "## 6. Putting it all together: dying while left-handed (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@context"
    ]
   },
   "source": [
    "Now we have the means of calculating all three quantities we need: P(A), P(LH), and P(LH | A). We can combine all three using Bayes' rule to get P(A | LH), the probability of being age A at death (in the study year) given that you're left-handed. To make this answer meaningful, though, we also want to compare it to P(A | RH), the probability of being age A at death given that you're right-handed. \n",
    "\n",
    "We're calculating the following quantity twice, once for left-handers and once for right-handers.\n",
    "\n",
    "$$P(A | LH) = \\frac{P(LH|A) P(A)}{P(LH)}$$\n",
    "\n",
    "\n",
    "First, for left-handers.\n",
    "\n",
    "<!--Notice that I was careful not to call these \"probability of dying at age A\", since that's not actually what we're calculating: we use the exact same death distribution data for each. -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@instructions"
    ]
   },
   "source": [
    "Write a function to calculate `P_A_given_lh()`.\n",
    "- Calculate `P_A`, the overall probability of dying at age A, which is given by `death_distribution_data` at age A divided by the total number of dead people (the sum of the `Both Sexes` column of `death_distribution_data`).\n",
    "- Calculate the overall probability of left-handedness P(LH) using the function defined in Task 5.\n",
    "- Calculate P(LH | A) using the function defined in Task 3.\n",
    "\n",
    "<hr>\n",
    "\n",
    "Helpful links:\n",
    "- [Python functions](https://www.w3schools.com/python/python_functions.asp)\n",
    "- [Bayes' theorem](https://en.wikipedia.org/wiki/Bayes%27_theorem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@hint"
    ]
   },
   "source": [
    "To calculate P(A) for particular ages of death A, divide `death_distribution_data['Both Sexes'][ages_of_death]` by the sum of the \"Both Sexes\" column. To calculate the sum, try something like this:\n",
    "\n",
    "```python\n",
    "death_distribution_data['Both Sexes'].sum() \n",
    "# or\n",
    "np.sum(death_distribution_data['Both Sexes'])\n",
    "```\n",
    "\n",
    "For the function `P_A_given_lh()`, return `P_lh_A*P_A/P_left`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "@sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "def P_A_given_lh(ages_of_death, death_distribution_data, study_year = 1990):\n",
    "    \"\"\" The overall probability of being a particular `age_of_death` given that you're left-handed \"\"\"\n",
    "    P_A = ...\n",
    "    P_left = ... # use P_lh function to get probability of left-handedness overall\n",
    "    P_lh_A = ... # use P_lh_given_A to get probability of left-handedness for a certain age\n",
    "    return P_lh_A*P_A/P_left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": [
     "@solution"
    ]
   },
   "outputs": [],
   "source": [
    "def P_A_given_lh(ages_of_death, death_distribution_data, study_year = 1990):\n",
    "    \"\"\" The overall probability of being a particular `age_of_death` given that you're left-handed \"\"\"\n",
    "    P_A = death_distribution_data['Both Sexes'][ages_of_death] / np.sum(death_distribution_data['Both Sexes'])\n",
    "    P_left = P_lh(death_distribution_data, study_year) # use P_lh function to get probability of left-handedness overall\n",
    "    P_lh_A = P_lh_given_A(ages_of_death, study_year) # use P_lh_given_A to get probability of left-handedness for a certain age\n",
    "    return P_lh_A*P_A/P_left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": [
     "@tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 4, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_output_type\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_output_is_probability\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_output_sums_to_1\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_study_year\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "4/4 tests passed\n"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "def test_output_type():\n",
    "    test_input = np.array([60])\n",
    "    assert (type(P_A_given_lh(test_input, death_distribution_data)) == pd.core.series.Series), \\\n",
    "    'Have you defined a function called P_A_given_lh that returns a pandas Series?'\n",
    "\n",
    "def test_output_is_probability():\n",
    "    test_input = np.array([60])\n",
    "    assert (P_A_given_lh(test_input, death_distribution_data) < 1).all(), \\\n",
    "    'Make sure the function returns numbers that are less than 1.'\n",
    "    \n",
    "def test_output_sums_to_1():\n",
    "    test_input = np.arange(0,115)\n",
    "    assert (round(np.nansum(P_A_given_lh(test_input, death_distribution_data)), 2) == 1), \\\n",
    "    'P_A_given_lh(np.arange(0,115), death_distribtuion_data) should sum up to 1.'\n",
    "\n",
    "def test_study_year():\n",
    "    test_input = np.array([45])\n",
    "    assert (P_A_given_lh(test_input, death_distribution_data) > \n",
    "            P_A_given_lh(test_input, death_distribution_data, 2018)).all(), \\\n",
    "    'Make sure to include `study_year` as the third argument for the function P_A_given_lh()'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "type:NotebookTask"
    ]
   },
   "source": [
    "## 7. Putting it all together: dying while left-handed (ii)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@context"
    ]
   },
   "source": [
    "And now for right-handers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@instructions"
    ]
   },
   "source": [
    "Write a function to calculate `P_A_given_rh()`.\n",
    "- Calculate `P_A`, the overall probability of dying at age A, which is given by `death_distribution_data` at age A divided by the total number of dead people. (This value is the same as in task 6.)\n",
    "- Calculate the overall probability of right-handedness P(RH), which is 1-P(LH).\n",
    "- Calculate P(RH | A), which is 1 - P(LH | A).\n",
    "\n",
    "<hr>\n",
    "\n",
    "Helpful links:\n",
    "- [Python functions](https://www.w3schools.com/python/python_functions.asp)\n",
    "- [Bayes' theorem](https://en.wikipedia.org/wiki/Bayes%27_theorem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@hint"
    ]
   },
   "source": [
    "P(A) is the same for both `P_A_given_lh()` and `P_A_given_rh()`.\n",
    "\n",
    "For the function `P_A_given_rh()`, return `P_rh_A*P_A/P_right`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "@sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "def P_A_given_rh(ages_of_death, death_distribution_data, study_year = 1990):\n",
    "    \"\"\" The overall probability of being a particular `age_of_death` given that you're right-handed \"\"\"\n",
    "    P_A = ...\n",
    "    P_right = ... # either you're left-handed or right-handed, so P_right = 1 - P_left\n",
    "    P_rh_A = ... # P_rh_A = 1 - P_lh_A \n",
    "    return P_rh_A*P_A/P_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": [
     "@solution"
    ]
   },
   "outputs": [],
   "source": [
    "def P_A_given_rh(ages_of_death, death_distribution_data, study_year = 1990):\n",
    "    \"\"\" The overall probability of being a particular `age_of_death` given that you're right-handed \"\"\"\n",
    "    P_A = death_distribution_data['Both Sexes'][ages_of_death] / np.sum(death_distribution_data['Both Sexes'])\n",
    "    P_right = 1- P_lh(death_distribution_data, study_year) # either you're left-handed or right-handed, so these sum to 1\n",
    "    P_rh_A = 1-P_lh_given_A(ages_of_death, study_year) # these also sum to 1 \n",
    "    return P_rh_A*P_A/P_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": [
     "@tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 5, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_output_type\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_output_is_probability\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_output_sums_to_1\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_correct_trend\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_study_year\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "5/5 tests passed\n"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "def test_output_type():\n",
    "    test_input = np.array([60])\n",
    "    assert (type(P_A_given_rh(test_input, death_distribution_data)) == pd.core.series.Series), \\\n",
    "    'Have you defined a function called P_A_given_rh that returns a pandas Series?'\n",
    "\n",
    "def test_output_is_probability():\n",
    "    test_input = np.array([60])\n",
    "    assert (P_A_given_rh(test_input, death_distribution_data) < 1).all(), \\\n",
    "    'Make sure the function returns numbers that are less than 1.'\n",
    "\n",
    "def test_output_sums_to_1():\n",
    "    test_input = np.arange(0,115)\n",
    "    assert (round(np.nansum(P_A_given_rh(test_input, death_distribution_data)), 2) == 1), \\\n",
    "    'P_A_given_rh(np.arange(0,115), death_distribtuion_data) should sum up to 1.'\n",
    "    \n",
    "def test_correct_trend():\n",
    "    assert (P_A_given_lh(np.array([80]), death_distribution_data) < \n",
    "    P_A_given_rh(np.array([80]), death_distribution_data)).all(), \\\n",
    "    'Did you mix up any components of P_A_given_lh and P_A_given_rh?'\n",
    "\n",
    "def test_study_year():\n",
    "    test_input = np.array([45])\n",
    "    assert (P_A_given_rh(test_input, death_distribution_data) < \n",
    "            P_A_given_rh(test_input, death_distribution_data, 2018)).all(), \\\n",
    "    'Make sure to include `study_year` as the third argument for the function P_A_given_rh()'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "type:NotebookTask"
    ]
   },
   "source": [
    "## 8. Plotting the distributions of conditional probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@context"
    ]
   },
   "source": [
    "Now that we have functions to calculate the probability of being age A at death given that you're left-handed or right-handed, let's plot these probabilities for a range of ages of death from 6 to 120. \n",
    "\n",
    "Notice that the left-handed distribution has a bump below age 70: of the pool of deceased people, left-handed people are more likely to be younger. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@instructions"
    ]
   },
   "source": [
    "Plot the probability of being a certain age at death given that you're left- or right-handed for a range of ages.\n",
    "- Calculate `P_A_given_lh` and `P_A_given_rh` using the functions defined in Task 6.\n",
    "- Use the `.plot()` method to plot the results versus age.\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@hint"
    ]
   },
   "source": [
    "The functions `P_A_given_lh()` and `P_A_given_rh()` take an array of ages and the death distribution DataFrame as input. You can calculate the overall probability for each age with a single function call. Try something like this:\n",
    "\n",
    "```python\n",
    "left_handed_probability = P_A_given_lh(ages, death_distribution_data)\n",
    "```\n",
    "\n",
    "You can plot two lists or arrays of the same length (one for `x` values and one for `y` values) like this:\n",
    "\n",
    "```python\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(x_list, y_list, label = \"label for legend\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "@sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "ages = np.arange(6, 115, 1) # make a list of ages of death to plot\n",
    "\n",
    "# calculate the probability of being left- or right-handed for each \n",
    "left_handed_probability = P_A_given_lh(...)\n",
    "right_handed_probability = P_A_given_rh(...)\n",
    "\n",
    "# create a plot of the two probabilities vs. age\n",
    "fig, ax = plt.subplots() # create figure and axis objects\n",
    "ax.plot(ages, left_handed_probability, label = \"Left-handed\")\n",
    "ax.plot(..., ..., label = ...)\n",
    "ax.legend() # add a legend\n",
    "ax.set_xlabel(\"Age at death\")\n",
    "ax.set_ylabel(r\"Probability of being age A at death\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": [
     "@solution"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7fd3eec79710>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fd3eec6b320>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ages = np.arange(6,115,1) # make a list of ages of death to plot\n",
    "\n",
    "# for each age, calculate the probability of being left- or right-handed\n",
    "left_handed_probability = P_A_given_lh(ages, death_distribution_data)\n",
    "right_handed_probability = P_A_given_rh(ages, death_distribution_data)\n",
    "\n",
    "fig, ax = plt.subplots() # create figure and axis objects\n",
    "ax.plot(ages, left_handed_probability, label = \"Left-handed\")\n",
    "ax.plot(ages, right_handed_probability, label = \"Right-handed\")\n",
    "ax.legend()\n",
    "ax.set_xlabel(\"Age at death\")\n",
    "ax.set_ylabel(r\"Probability of being age A at death\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": [
     "@tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 5, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_list_length\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_list_values\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_lists_are_different\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_num_lines\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_plot_labels\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "5/5 tests passed\n"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "def test_list_length():\n",
    "    assert len(left_handed_probability) > 1 and len(right_handed_probability) > 1, \\\n",
    "    'Make sure you append values to each list for every age A in ages.'\n",
    "    \n",
    "def test_list_values():\n",
    "    assert np.max(left_handed_probability) < 1 and np.max(right_handed_probability) < 1, \\\n",
    "    'All the values in each list should be probabilities (less than 1)'\n",
    "\n",
    "def test_lists_are_different():\n",
    "    assert np.max(left_handed_probability) < np.max(right_handed_probability), \\\n",
    "    'Did you calculate separate values for left- and right-handed probabilities?'\n",
    "    \n",
    "def test_num_lines():\n",
    "    assert (len(ax.lines) == 2), \\\n",
    "    'Did you plot lefthanded rates for both men and women?'\n",
    "\n",
    "def test_plot_labels():\n",
    "    assert ax.get_xlabel() != '' and ax.get_ylabel() != '', \\\n",
    "    'Please add x and y labels to your plot.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "type:NotebookTask"
    ]
   },
   "source": [
    "## 9. Moment of truth: age of left and right-handers at death"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@context"
    ]
   },
   "source": [
    "Finally, let's compare our results with the original study that found that left-handed people were nine years younger at death on average. We can do this by calculating the mean of these probability distributions in the same way we calculated P(LH) earlier, weighting the probability distribution by age and summing over the result.\n",
    "\n",
    "$$\\text{Average age of left-handed people at death} = \\sum_A A P(A | LH)$$\n",
    "\n",
    "$$\\text{Average age of right-handed people at death} = \\sum_A A P(A | RH)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@instructions"
    ]
   },
   "source": [
    "Find the mean age at death for left-handers and right-handers.\n",
    "- Multiply the `ages` list by the left-handed probabilities of being those ages at death, then use `np.nansum` to calculate the sum. Assign the result to `average_lh_age`.\n",
    "- Do the same with the right-handed probabilities to calculate `average_rh_age`.\n",
    "- Print `average_lh_age` and `average_rh_age`.\n",
    "- Calculate the difference between the two average ages and print it.\n",
    "\n",
    "<hr>\n",
    "\n",
    "To make your printed output prettier, try using the `round()` function to round your results to two decimal places.\n",
    "\n",
    "Helpful links:\n",
    "\n",
    "* [`np.nansum()` documentation](https://docs.scipy.org/doc/numpy-1.10.4/reference/generated/numpy.nansum.html)\n",
    "* [`round()` documentation](https://www.programiz.com/python-programming/methods/built-in/round)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@hint"
    ]
   },
   "source": [
    "To calculate the average age of death for each group, multiply the list of `ages` by the list of probabilities stored in `left_handed_probability` and `right_handed_probability`. The result should be a single number. Try something like this:\n",
    "\n",
    "```python\n",
    "average_rh_age =  np.nansum(ages*np.array(right_handed_probability))\n",
    "```\n",
    "\n",
    "To round a number to `n` decimal places and print it to the screen, try something like this:\n",
    "\n",
    "```python\n",
    "print(round(my_variable, 2))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "@sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "# calculate average ages for left-handed and right-handed groups\n",
    "# use np.array so that two arrays can be multiplied\n",
    "average_lh_age =  np.nansum(...*np.array(...))\n",
    "average_rh_age =  np.nansum(...*np.array(...))\n",
    "\n",
    "# print the average ages for each group\n",
    "# ... YOUR CODE FOR TASK 9 ...\n",
    "\n",
    "# print the difference between the average ages\n",
    "print(\"The difference in average ages is \" + str(round(... - ..., 1)) + \" years.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": [
     "@solution"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "67.2\n",
      "72.8\n",
      "The difference in average ages is 5.5 years.\n"
     ]
    }
   ],
   "source": [
    "# calculate average ages for left-handed and right-handed groups\n",
    "# use np.array so that two arrays can be multiplied\n",
    "average_lh_age =  np.nansum(ages*np.array(left_handed_probability))\n",
    "average_rh_age =  np.nansum(ages*np.array(right_handed_probability))\n",
    "\n",
    "# print the average ages for each group\n",
    "print(round(average_lh_age,1))\n",
    "print(round(average_rh_age,1))\n",
    "\n",
    "# print the difference between the average ages\n",
    "print(\"The difference in average ages is \" + str(round(average_rh_age - average_lh_age, 1)) + \" years.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": [
     "@tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 2, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_result_type\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_average_ages\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2/2 tests passed\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "def test_result_type():\n",
    "    assert ((type(average_lh_age) == np.float64 or type(average_lh_age) == float) and\n",
    "            (type(average_rh_age) == np.float64 or type(average_rh_age) == float)), \\\n",
    "    'average_lh_age and average_rh age should each be a single number.'\n",
    "\n",
    "def test_average_ages():\n",
    "    assert average_lh_age < average_rh_age, \\\n",
    "    'You should get a smaller number for average_lh_age than average_rh_age.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "type:NotebookTask"
    ]
   },
   "source": [
    "## 10. Final comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@context"
    ]
   },
   "source": [
    "We got a pretty big age gap between left-handed and right-handed people purely as a result of the changing rates of left-handedness in the population, which is good news for left-handers: you probably won't die young because of your sinisterness. The reported rates of left-handedness have increased from just 3% in the early 1900s to about 11% today, which means that older people are much more likely to be reported as right-handed than left-handed, and so looking at a sample of recently deceased people will have more old right-handers.\n",
    "\n",
    "Our number is still less than the 9-year gap measured in the study. It's possible that some of the approximations we made are the cause: \n",
    "\n",
    "1. We used death distribution data from almost ten years after the study (1999 instead of 1991), and we used death data from the entire United States instead of California alone (which was the original study). \n",
    "2. We extrapolated the left-handedness survey results to older and younger age groups, but it's possible our extrapolation wasn't close enough to the true rates for those ages. \n",
    "\n",
    "One thing we could do next is figure out how much variability we would expect to encounter in the age difference purely because of random sampling: if you take a smaller sample of recently deceased people and assign handedness with the probabilities of the survey, what does that distribution look like? How often would we encounter an age gap of nine years using the same data and assumptions? We won't do that here, but it's possible with this data and the tools of random sampling. \n",
    "\n",
    "<!-- I did do this if we want to add more tasks - it would probably take three more blocks.-->\n",
    "\n",
    "To finish off, let's calculate the age gap we'd expect if we did the study in 2018 instead of in 1990. The gap turns out to be much smaller since rates of left-handedness haven't increased for people born after about 1960. Both the National Geographic study and the 1990 study happened at a unique time - the rates of left-handedness had been changing across the lifetimes of most people alive, and the difference in handedness between old and young was at its most striking. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@instructions"
    ]
   },
   "source": [
    "Redo the calculation from Task 8, setting the `study_year` parameter to 2018.\n",
    "- In the call to `P_A_given_lh`, set `age_of_death` to `ages`, `death_distribution_data` to `death_distribution_data`, and `study_year` to 2018.\n",
    "- Do the same for `P_A_given_rh`.\n",
    "\n",
    "<hr>\n",
    "\n",
    "You can read more about this interpretation of the study in this [BBC article](www.bbc.com/news/magazine-23988352)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "@hint"
    ]
   },
   "source": [
    "The first function call should look like this:\n",
    "\n",
    "```python\n",
    "P_A_given_lh(ages, death_distribution_data, study_year = 2018)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "@sample_code"
    ]
   },
   "outputs": [],
   "source": [
    "# Calculate the probability of being left- or right-handed for all ages\n",
    "left_handed_probability_2018 = ...\n",
    "right_handed_probability_2018 = ...\n",
    "\n",
    "# calculate average ages for left-handed and right-handed groups\n",
    "average_lh_age_2018 = np.nansum(ages*np.array(left_handed_probability_2018))\n",
    "average_rh_age_2018 = np.nansum(ages*np.array(right_handed_probability_2018))\n",
    "\n",
    "print(\"The difference in average ages is \" + \n",
    "      str(round(average_rh_age_2018 - average_lh_age_2018, 1)) + \" years.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": [
     "@solution"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The difference in average ages is 2.3 years.\n"
     ]
    }
   ],
   "source": [
    "# loop through ages, calculating the probability of being left- or right-handed\n",
    "left_handed_probability_2018 = P_A_given_lh(ages, death_distribution_data, study_year = 2018)\n",
    "right_handed_probability_2018 = P_A_given_rh(ages, death_distribution_data, study_year = 2018)\n",
    "    \n",
    "# calculate average ages for left-handed and right-handed groups\n",
    "average_lh_age_2018 =  np.nansum(ages*np.array(left_handed_probability_2018))\n",
    "average_rh_age_2018 =  np.nansum(ages*np.array(right_handed_probability_2018))\n",
    "\n",
    "print(\"The difference in average ages is \" + \n",
    "      str(round(average_rh_age_2018 - average_lh_age_2018, 1)) + \" years.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": [
     "@tests"
    ]
   },
   "outputs": [
    {
     "data": {
      "application/json": "{\"success\": true, \"summary\": {\"tests\": 4, \"failures\": 0, \"errors\": 0}, \"tests\": [{\"name\": \"__main__.test_list_length\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_list_values\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_lists_are_different\", \"success\": true, \"message\": \"\"}, {\"name\": \"__main__.test_average_ages\", \"success\": true, \"message\": \"\"}]}"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "4/4 tests passed\n"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%nose\n",
    "\n",
    "# def test_current_year():\n",
    "#     import datetime\n",
    "#     now = datetime.datetime.now()\n",
    "#     assert current_year >= now.year, \\\n",
    "#     'Did you set the \"current_year\" variable to the current year?'\n",
    "\n",
    "def test_list_length():\n",
    "    assert len(left_handed_probability_2018) > 1 and len(right_handed_probability_2018) > 1, \\\n",
    "    'Make sure you append values to each list for every age A in ages.'\n",
    "    \n",
    "def test_list_values():\n",
    "    assert np.max(left_handed_probability_2018) < 1 and np.max(right_handed_probability_2018) < 1, \\\n",
    "    'All the values in each list should be probabilities (less than 1).'\n",
    "\n",
    "def test_lists_are_different():\n",
    "    assert (left_handed_probability_2018 != right_handed_probability_2018).all(), \\\n",
    "    'Did you calculate separate values for left and right-handed probabilities?'\n",
    "    \n",
    "def test_average_ages():\n",
    "    assert (average_rh_age_2018 - average_lh_age_2018 < 4), \\\n",
    "    'The difference in ages between the left-handed and right-handed groups should be less than the value you calculated for the 1990 study.'"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}