{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 3\n",
    "\n",
    "Examples and Exercises from Think Stats, 2nd Edition\n",
    "\n",
    "http://thinkstats2.com\n",
    "\n",
    "Copyright 2016 Allen B. Downey\n",
    "\n",
    "MIT License: https://opensource.org/licenses/MIT\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 2;\n",
       "                var nbb_unformatted_code = \"from os.path import basename, exists\\n\\n\\ndef download(url):\\n    filename = basename(url)\\n    if not exists(filename):\\n        from urllib.request import urlretrieve\\n\\n        local, _ = urlretrieve(url, filename)\\n        print(\\\"Downloaded \\\" + local)\\n\\n\\ndownload(\\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/thinkstats2.py\\\")\\ndownload(\\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/thinkplot.py\\\")\\ndownload(\\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/nsfg.py\\\")\\ndownload(\\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/first.py\\\")\\n\\ndownload(\\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemPreg.dct\\\")\\ndownload(\\n    \\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemPreg.dat.gz\\\"\\n)\";\n",
       "                var nbb_formatted_code = \"from os.path import basename, exists\\n\\n\\ndef download(url):\\n    filename = basename(url)\\n    if not exists(filename):\\n        from urllib.request import urlretrieve\\n\\n        local, _ = urlretrieve(url, filename)\\n        print(\\\"Downloaded \\\" + local)\\n\\n\\ndownload(\\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/thinkstats2.py\\\")\\ndownload(\\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/thinkplot.py\\\")\\ndownload(\\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/nsfg.py\\\")\\ndownload(\\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/first.py\\\")\\n\\ndownload(\\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemPreg.dct\\\")\\ndownload(\\n    \\\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemPreg.dat.gz\\\"\\n)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from os.path import basename, exists\n",
    "\n",
    "\n",
    "def download(url):\n",
    "    filename = basename(url)\n",
    "    if not exists(filename):\n",
    "        from urllib.request import urlretrieve\n",
    "\n",
    "        local, _ = urlretrieve(url, filename)\n",
    "        print(\"Downloaded \" + local)\n",
    "\n",
    "\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/thinkstats2.py\")\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/thinkplot.py\")\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/nsfg.py\")\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/first.py\")\n",
    "\n",
    "\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemPreg.dct\")\n",
    "download(\n",
    "    \"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemPreg.dat.gz\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 3;\n",
       "                var nbb_unformatted_code = \"import numpy as np\";\n",
       "                var nbb_formatted_code = \"import numpy as np\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, I'll load the NSFG pregnancy file and select live births:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 4;\n",
       "                var nbb_unformatted_code = \"import nsfg\\nimport first\\nimport thinkstats2\\nimport thinkplot\";\n",
       "                var nbb_formatted_code = \"import nsfg\\nimport first\\nimport thinkstats2\\nimport thinkplot\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import nsfg\n",
    "import first\n",
    "import thinkstats2\n",
    "import thinkplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 5;\n",
       "                var nbb_unformatted_code = \"preg = nsfg.ReadFemPreg()\\nlive = preg[preg.outcome == 1]\";\n",
       "                var nbb_formatted_code = \"preg = nsfg.ReadFemPreg()\\nlive = preg[preg.outcome == 1]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "preg = nsfg.ReadFemPreg()\n",
    "live = preg[preg.outcome == 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the histogram of birth weights:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 6;\n",
       "                var nbb_unformatted_code = \"hist = thinkstats2.Hist(live.birthwgt_lb, label='birthwgt_lb')\\nthinkplot.Hist(hist)\\nthinkplot.Config(xlabel='Birth weight (pounds)', ylabel='Count')\";\n",
       "                var nbb_formatted_code = \"hist = thinkstats2.Hist(live.birthwgt_lb, label=\\\"birthwgt_lb\\\")\\nthinkplot.Hist(hist)\\nthinkplot.Config(xlabel=\\\"Birth weight (pounds)\\\", ylabel=\\\"Count\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist = thinkstats2.Hist(live.birthwgt_lb, label=\"birthwgt_lb\")\n",
    "thinkplot.Hist(hist)\n",
    "thinkplot.Config(xlabel=\"Birth weight (pounds)\", ylabel=\"Count\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To normalize the disrtibution, we could divide through by the total count:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 7;\n",
       "                var nbb_unformatted_code = \"n = hist.Total()\\npmf = hist.Copy()\\nfor x, freq in hist.Items():\\n    pmf[x] = freq / n\";\n",
       "                var nbb_formatted_code = \"n = hist.Total()\\npmf = hist.Copy()\\nfor x, freq in hist.Items():\\n    pmf[x] = freq / n\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = hist.Total()\n",
    "pmf = hist.Copy()\n",
    "for x, freq in hist.Items():\n",
    "    pmf[x] = freq / n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is a Probability Mass Function (PMF)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 8;\n",
       "                var nbb_unformatted_code = \"thinkplot.Hist(pmf)\\nthinkplot.Config(xlabel='Birth weight (pounds)', ylabel='PMF')\";\n",
       "                var nbb_formatted_code = \"thinkplot.Hist(pmf)\\nthinkplot.Config(xlabel=\\\"Birth weight (pounds)\\\", ylabel=\\\"PMF\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "thinkplot.Hist(pmf)\n",
    "thinkplot.Config(xlabel=\"Birth weight (pounds)\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More directly, we can create a Pmf object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pmf({1: 0.2, 2: 0.4, 3: 0.2, 5: 0.2})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 9;\n",
       "                var nbb_unformatted_code = \"pmf = thinkstats2.Pmf([1, 2, 2, 3, 5])\\npmf\";\n",
       "                var nbb_formatted_code = \"pmf = thinkstats2.Pmf([1, 2, 2, 3, 5])\\npmf\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pmf = thinkstats2.Pmf([1, 2, 2, 3, 5])\n",
    "pmf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Pmf` provides `Prob`, which looks up a value and returns its probability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 10;\n",
       "                var nbb_unformatted_code = \"pmf.Prob(2)\";\n",
       "                var nbb_formatted_code = \"pmf.Prob(2)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pmf.Prob(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The bracket operator does the same thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 11;\n",
       "                var nbb_unformatted_code = \"pmf[2]\";\n",
       "                var nbb_formatted_code = \"pmf[2]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pmf[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Incr` method adds to the probability associated with a given values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6000000000000001"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 12;\n",
       "                var nbb_unformatted_code = \"pmf.Incr(2, 0.2)\\npmf[2]\";\n",
       "                var nbb_formatted_code = \"pmf.Incr(2, 0.2)\\npmf[2]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pmf.Incr(2, 0.2)\n",
    "pmf[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Mult` method multiplies the probability associated with a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30000000000000004"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 13;\n",
       "                var nbb_unformatted_code = \"pmf.Mult(2, 0.5)\\npmf[2]\";\n",
       "                var nbb_formatted_code = \"pmf.Mult(2, 0.5)\\npmf[2]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pmf.Mult(2, 0.5)\n",
    "pmf[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Total` returns the total probability (which is no longer 1, because we changed one of the probabilities)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8999999999999999"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 14;\n",
       "                var nbb_unformatted_code = \"pmf.Total()\";\n",
       "                var nbb_formatted_code = \"pmf.Total()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pmf.Total()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Normalize` divides through by the total probability, making it 1 again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 15;\n",
       "                var nbb_unformatted_code = \"pmf.Normalize()\\npmf.Total()\";\n",
       "                var nbb_formatted_code = \"pmf.Normalize()\\npmf.Total()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pmf.Normalize()\n",
    "pmf.Total()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the PMF of pregnancy length for live births."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 16;\n",
       "                var nbb_unformatted_code = \"pmf = thinkstats2.Pmf(live.prglngth, label='prglngth')\";\n",
       "                var nbb_formatted_code = \"pmf = thinkstats2.Pmf(live.prglngth, label=\\\"prglngth\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pmf = thinkstats2.Pmf(live.prglngth, label=\"prglngth\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what it looks like plotted with `Hist`, which makes a bar graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 17;\n",
       "                var nbb_unformatted_code = \"thinkplot.Hist(pmf)\\nthinkplot.Config(xlabel='Pregnancy length (weeks)', ylabel='Pmf')\";\n",
       "                var nbb_formatted_code = \"thinkplot.Hist(pmf)\\nthinkplot.Config(xlabel=\\\"Pregnancy length (weeks)\\\", ylabel=\\\"Pmf\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "thinkplot.Hist(pmf)\n",
    "thinkplot.Config(xlabel=\"Pregnancy length (weeks)\", ylabel=\"Pmf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what it looks like plotted with `Pmf`, which makes a step function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 18;\n",
       "                var nbb_unformatted_code = \"thinkplot.Pmf(pmf)\\nthinkplot.Config(xlabel='Pregnancy length (weeks)', ylabel='Pmf')\";\n",
       "                var nbb_formatted_code = \"thinkplot.Pmf(pmf)\\nthinkplot.Config(xlabel=\\\"Pregnancy length (weeks)\\\", ylabel=\\\"Pmf\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "thinkplot.Pmf(pmf)\n",
    "thinkplot.Config(xlabel=\"Pregnancy length (weeks)\", ylabel=\"Pmf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use `MakeFrames` to return DataFrames for all live births, first babies, and others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 19;\n",
       "                var nbb_unformatted_code = \"live, firsts, others = first.MakeFrames()\";\n",
       "                var nbb_formatted_code = \"live, firsts, others = first.MakeFrames()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "live, firsts, others = first.MakeFrames()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are the distributions of pregnancy length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 20;\n",
       "                var nbb_unformatted_code = \"first_pmf = thinkstats2.Pmf(firsts.prglngth, label='firsts')\\nother_pmf = thinkstats2.Pmf(others.prglngth, label='others')\";\n",
       "                var nbb_formatted_code = \"first_pmf = thinkstats2.Pmf(firsts.prglngth, label=\\\"firsts\\\")\\nother_pmf = thinkstats2.Pmf(others.prglngth, label=\\\"others\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "first_pmf = thinkstats2.Pmf(firsts.prglngth, label=\"firsts\")\n",
    "other_pmf = thinkstats2.Pmf(others.prglngth, label=\"others\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here's the code that replicates one of the figures in the chapter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 21;\n",
       "                var nbb_unformatted_code = \"width=0.45\\naxis = [27, 46, 0, 0.6]\\nthinkplot.PrePlot(2, cols=2)\\nthinkplot.Hist(first_pmf, align='right', width=width)\\nthinkplot.Hist(other_pmf, align='left', width=width)\\nthinkplot.Config(xlabel='Pregnancy length(weeks)', ylabel='PMF', axis=axis)\\n\\nthinkplot.PrePlot(2)\\nthinkplot.SubPlot(2)\\nthinkplot.Pmfs([first_pmf, other_pmf])\\nthinkplot.Config(xlabel='Pregnancy length(weeks)', axis=axis)\";\n",
       "                var nbb_formatted_code = \"width = 0.45\\naxis = [27, 46, 0, 0.6]\\nthinkplot.PrePlot(2, cols=2)\\nthinkplot.Hist(first_pmf, align=\\\"right\\\", width=width)\\nthinkplot.Hist(other_pmf, align=\\\"left\\\", width=width)\\nthinkplot.Config(xlabel=\\\"Pregnancy length(weeks)\\\", ylabel=\\\"PMF\\\", axis=axis)\\n\\nthinkplot.PrePlot(2)\\nthinkplot.SubPlot(2)\\nthinkplot.Pmfs([first_pmf, other_pmf])\\nthinkplot.Config(xlabel=\\\"Pregnancy length(weeks)\\\", axis=axis)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "width = 0.45\n",
    "axis = [27, 46, 0, 0.6]\n",
    "thinkplot.PrePlot(2, cols=2)\n",
    "thinkplot.Hist(first_pmf, align=\"right\", width=width)\n",
    "thinkplot.Hist(other_pmf, align=\"left\", width=width)\n",
    "thinkplot.Config(xlabel=\"Pregnancy length(weeks)\", ylabel=\"PMF\", axis=axis)\n",
    "\n",
    "thinkplot.PrePlot(2)\n",
    "thinkplot.SubPlot(2)\n",
    "thinkplot.Pmfs([first_pmf, other_pmf])\n",
    "thinkplot.Config(xlabel=\"Pregnancy length(weeks)\", axis=axis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the code that generates a plot of the difference in probability (in percentage points) between first babies and others, for each week of pregnancy (showing only pregnancies considered \"full term\"). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 22;\n",
       "                var nbb_unformatted_code = \"weeks = range(35, 46)\\ndiffs = []\\nfor week in weeks:\\n    p1 = first_pmf.Prob(week)\\n    p2 = other_pmf.Prob(week)\\n    diff = 100 * (p1 - p2)\\n    diffs.append(diff)\\n\\nthinkplot.Bar(weeks, diffs)\\nthinkplot.Config(xlabel='Pregnancy length(weeks)', ylabel='Difference (percentage points)')\";\n",
       "                var nbb_formatted_code = \"weeks = range(35, 46)\\ndiffs = []\\nfor week in weeks:\\n    p1 = first_pmf.Prob(week)\\n    p2 = other_pmf.Prob(week)\\n    diff = 100 * (p1 - p2)\\n    diffs.append(diff)\\n\\nthinkplot.Bar(weeks, diffs)\\nthinkplot.Config(\\n    xlabel=\\\"Pregnancy length(weeks)\\\", ylabel=\\\"Difference (percentage points)\\\"\\n)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "weeks = range(35, 46)\n",
    "diffs = []\n",
    "for week in weeks:\n",
    "    p1 = first_pmf.Prob(week)\n",
    "    p2 = other_pmf.Prob(week)\n",
    "    diff = 100 * (p1 - p2)\n",
    "    diffs.append(diff)\n",
    "\n",
    "thinkplot.Bar(weeks, diffs)\n",
    "thinkplot.Config(xlabel='Pregnancy length(weeks)', ylabel='Difference (percentage points)')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Biasing and unbiasing PMFs\n",
    "\n",
    "Here's the example in the book showing operations we can perform with `Pmf` objects.\n",
    "\n",
    "Suppose we have the following distribution of class sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 23;\n",
       "                var nbb_unformatted_code = \"d = { 7: 8, 12: 8, 17: 14, 22: 4, \\n     27: 6, 32: 12, 37: 8, 42: 3, 47: 2 }\\n\\npmf = thinkstats2.Pmf(d, label='actual')\";\n",
       "                var nbb_formatted_code = \"d = {7: 8, 12: 8, 17: 14, 22: 4, 27: 6, 32: 12, 37: 8, 42: 3, 47: 2}\\n\\npmf = thinkstats2.Pmf(d, label=\\\"actual\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "d = {7: 8, 12: 8, 17: 14, 22: 4, 27: 6, 32: 12, 37: 8, 42: 3, 47: 2}\n",
    "\n",
    "pmf = thinkstats2.Pmf(d, label=\"actual\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function computes the biased PMF we would get if we surveyed students and asked about the size of the classes they are in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 24;\n",
       "                var nbb_unformatted_code = \"def BiasPmf(pmf, label):\\n    new_pmf = pmf.Copy(label=label)\\n\\n    for x, p in pmf.Items():\\n        new_pmf.Mult(x, x)\\n        \\n    new_pmf.Normalize()\\n    return new_pmf\";\n",
       "                var nbb_formatted_code = \"def BiasPmf(pmf, label):\\n    new_pmf = pmf.Copy(label=label)\\n\\n    for x, p in pmf.Items():\\n        new_pmf.Mult(x, x)\\n\\n    new_pmf.Normalize()\\n    return new_pmf\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def BiasPmf(pmf, label):\n",
    "    new_pmf = pmf.Copy(label=label)\n",
    "\n",
    "    for x, p in pmf.Items():\n",
    "        new_pmf.Mult(x, x)\n",
    "\n",
    "    new_pmf.Normalize()\n",
    "    return new_pmf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following graph shows the difference between the actual and observed distributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 25;\n",
       "                var nbb_unformatted_code = \"biased_pmf = BiasPmf(pmf, label='observed')\\nthinkplot.PrePlot(2)\\nthinkplot.Pmfs([pmf, biased_pmf])\\nthinkplot.Config(xlabel='Class size', ylabel='PMF')\";\n",
       "                var nbb_formatted_code = \"biased_pmf = BiasPmf(pmf, label=\\\"observed\\\")\\nthinkplot.PrePlot(2)\\nthinkplot.Pmfs([pmf, biased_pmf])\\nthinkplot.Config(xlabel=\\\"Class size\\\", ylabel=\\\"PMF\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "biased_pmf = BiasPmf(pmf, label=\"observed\")\n",
    "thinkplot.PrePlot(2)\n",
    "thinkplot.Pmfs([pmf, biased_pmf])\n",
    "thinkplot.Config(xlabel=\"Class size\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The observed mean is substantially higher than the actual."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual mean 23.692307692307693\n",
      "Observed mean 29.123376623376625\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 26;\n",
       "                var nbb_unformatted_code = \"print('Actual mean', pmf.Mean())\\nprint('Observed mean', biased_pmf.Mean())\";\n",
       "                var nbb_formatted_code = \"print(\\\"Actual mean\\\", pmf.Mean())\\nprint(\\\"Observed mean\\\", biased_pmf.Mean())\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"Actual mean\", pmf.Mean())\n",
    "print(\"Observed mean\", biased_pmf.Mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we were only able to collect the biased sample, we could \"unbias\" it by applying the inverse operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 27;\n",
       "                var nbb_unformatted_code = \"def UnbiasPmf(pmf, label=None):\\n    new_pmf = pmf.Copy(label=label)\\n\\n    for x, p in pmf.Items():\\n        new_pmf[x] *= 1/x\\n        \\n    new_pmf.Normalize()\\n    return new_pmf\";\n",
       "                var nbb_formatted_code = \"def UnbiasPmf(pmf, label=None):\\n    new_pmf = pmf.Copy(label=label)\\n\\n    for x, p in pmf.Items():\\n        new_pmf[x] *= 1 / x\\n\\n    new_pmf.Normalize()\\n    return new_pmf\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def UnbiasPmf(pmf, label=None):\n",
    "    new_pmf = pmf.Copy(label=label)\n",
    "\n",
    "    for x, p in pmf.Items():\n",
    "        new_pmf[x] *= 1 / x\n",
    "\n",
    "    new_pmf.Normalize()\n",
    "    return new_pmf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can unbias the biased PMF:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unbiased mean 23.69230769230769\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 28;\n",
       "                var nbb_unformatted_code = \"unbiased = UnbiasPmf(biased_pmf, label='unbiased')\\nprint('Unbiased mean', unbiased.Mean())\";\n",
       "                var nbb_formatted_code = \"unbiased = UnbiasPmf(biased_pmf, label=\\\"unbiased\\\")\\nprint(\\\"Unbiased mean\\\", unbiased.Mean())\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "unbiased = UnbiasPmf(biased_pmf, label=\"unbiased\")\n",
    "print(\"Unbiased mean\", unbiased.Mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And plot the two distributions to confirm they are the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 29;\n",
       "                var nbb_unformatted_code = \"thinkplot.PrePlot(2)\\nthinkplot.Pmfs([pmf, unbiased])\\nthinkplot.Config(xlabel='Class size', ylabel='PMF')\";\n",
       "                var nbb_formatted_code = \"thinkplot.PrePlot(2)\\nthinkplot.Pmfs([pmf, unbiased])\\nthinkplot.Config(xlabel=\\\"Class size\\\", ylabel=\\\"PMF\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "thinkplot.PrePlot(2)\n",
    "thinkplot.Pmfs([pmf, unbiased])\n",
    "thinkplot.Config(xlabel=\"Class size\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas indexing\n",
    "\n",
    "Here's an example of a small DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.360839</td>\n",
       "      <td>-0.653037</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.055034</td>\n",
       "      <td>-0.008179</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.988534</td>\n",
       "      <td>2.137857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.028142</td>\n",
       "      <td>1.087482</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1\n",
       "0  1.360839 -0.653037\n",
       "1  0.055034 -0.008179\n",
       "2 -0.988534  2.137857\n",
       "3  1.028142  1.087482"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 30;\n",
       "                var nbb_unformatted_code = \"import numpy as np\\nimport pandas\\narray = np.random.randn(4, 2)\\ndf = pandas.DataFrame(array)\\ndf\";\n",
       "                var nbb_formatted_code = \"import numpy as np\\nimport pandas\\n\\narray = np.random.randn(4, 2)\\ndf = pandas.DataFrame(array)\\ndf\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas\n",
    "\n",
    "array = np.random.randn(4, 2)\n",
    "df = pandas.DataFrame(array)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can specify column names when we create the DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.360839</td>\n",
       "      <td>-0.653037</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.055034</td>\n",
       "      <td>-0.008179</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.988534</td>\n",
       "      <td>2.137857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.028142</td>\n",
       "      <td>1.087482</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "0  1.360839 -0.653037\n",
       "1  0.055034 -0.008179\n",
       "2 -0.988534  2.137857\n",
       "3  1.028142  1.087482"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 31;\n",
       "                var nbb_unformatted_code = \"columns = ['A', 'B']\\ndf = pandas.DataFrame(array, columns=columns)\\ndf\";\n",
       "                var nbb_formatted_code = \"columns = [\\\"A\\\", \\\"B\\\"]\\ndf = pandas.DataFrame(array, columns=columns)\\ndf\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "columns = [\"A\", \"B\"]\n",
    "df = pandas.DataFrame(array, columns=columns)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also specify an index that contains labels for the rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1.360839</td>\n",
       "      <td>-0.653037</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>0.055034</td>\n",
       "      <td>-0.008179</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>-0.988534</td>\n",
       "      <td>2.137857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>1.028142</td>\n",
       "      <td>1.087482</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "a  1.360839 -0.653037\n",
       "b  0.055034 -0.008179\n",
       "c -0.988534  2.137857\n",
       "d  1.028142  1.087482"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 32;\n",
       "                var nbb_unformatted_code = \"index = ['a', 'b', 'c', 'd']\\ndf = pandas.DataFrame(array, columns=columns, index=index)\\ndf\";\n",
       "                var nbb_formatted_code = \"index = [\\\"a\\\", \\\"b\\\", \\\"c\\\", \\\"d\\\"]\\ndf = pandas.DataFrame(array, columns=columns, index=index)\\ndf\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "index = [\"a\", \"b\", \"c\", \"d\"]\n",
    "df = pandas.DataFrame(array, columns=columns, index=index)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normal indexing selects columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    1.360839\n",
       "b    0.055034\n",
       "c   -0.988534\n",
       "d    1.028142\n",
       "Name: A, dtype: float64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 33;\n",
       "                var nbb_unformatted_code = \"df['A']\";\n",
       "                var nbb_formatted_code = \"df[\\\"A\\\"]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df[\"A\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the `loc` attribute to select rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A    1.360839\n",
       "B   -0.653037\n",
       "Name: a, dtype: float64"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 34;\n",
       "                var nbb_unformatted_code = \"df.loc['a']\";\n",
       "                var nbb_formatted_code = \"df.loc[\\\"a\\\"]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.loc[\"a\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you don't want to use the row labels and prefer to access the rows using integer indices, you can use the `iloc` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A    1.360839\n",
       "B   -0.653037\n",
       "Name: a, dtype: float64"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 35;\n",
       "                var nbb_unformatted_code = \"df.iloc[0]\";\n",
       "                var nbb_formatted_code = \"df.iloc[0]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.iloc[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`loc` can also take a list of labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1.360839</td>\n",
       "      <td>-0.653037</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>-0.988534</td>\n",
       "      <td>2.137857</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "a  1.360839 -0.653037\n",
       "c -0.988534  2.137857"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 36;\n",
       "                var nbb_unformatted_code = \"indices = ['a', 'c']\\ndf.loc[indices]\";\n",
       "                var nbb_formatted_code = \"indices = [\\\"a\\\", \\\"c\\\"]\\ndf.loc[indices]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "indices = [\"a\", \"c\"]\n",
    "df.loc[indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you provide a slice of labels, `DataFrame` uses it to select rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1.360839</td>\n",
       "      <td>-0.653037</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>0.055034</td>\n",
       "      <td>-0.008179</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>-0.988534</td>\n",
       "      <td>2.137857</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "a  1.360839 -0.653037\n",
       "b  0.055034 -0.008179\n",
       "c -0.988534  2.137857"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 37;\n",
       "                var nbb_unformatted_code = \"df['a':'c']\";\n",
       "                var nbb_formatted_code = \"df[\\\"a\\\":\\\"c\\\"]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df[\"a\":\"c\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you provide a slice of integers, `DataFrame` selects rows by integer index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>1.360839</td>\n",
       "      <td>-0.653037</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>0.055034</td>\n",
       "      <td>-0.008179</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          A         B\n",
       "a  1.360839 -0.653037\n",
       "b  0.055034 -0.008179"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 38;\n",
       "                var nbb_unformatted_code = \"df[0:2]\";\n",
       "                var nbb_formatted_code = \"df[0:2]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But notice that one method includes the last elements of the slice and one does not.\n",
    "\n",
    "In general, I recommend giving labels to the rows and names to the columns, and using them consistently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** In Chapter 3 we computed the mean of a sample by adding up\n",
    "the elements and dividing by n.  If you are given a PMF, you can\n",
    "still compute the mean, but the process is slightly different:\n",
    "%\n",
    "$$ \\bar x = \\sum_i p_i~x_i $$\n",
    "%\n",
    "where the $x_i$ are the unique values in the PMF and $p_i=PMF(x_i)$.\n",
    "Similarly, you can compute variance like this:\n",
    "%\n",
    "$$ S^2 = \\sum_i p_i~(x_i - \\bar x)^2 $$\n",
    "% \n",
    "Write functions called `PmfMean` and `PmfVar` that take a\n",
    "Pmf object and compute the mean and variance.  To test these methods,\n",
    "check that they are consistent with the methods `Mean` and `Var`\n",
    "provided by `Pmf`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 39;\n",
       "                var nbb_unformatted_code = \"def PmfMean(pmf):\\n        \\\"\\\"\\\"Computes the mean of a PMF.\\n        Returns:\\n            float mean\\n        \\\"\\\"\\\"\\n        return sum(p * x for x, p in pmf.Items())\";\n",
       "                var nbb_formatted_code = \"def PmfMean(pmf):\\n    \\\"\\\"\\\"Computes the mean of a PMF.\\n    Returns:\\n        float mean\\n    \\\"\\\"\\\"\\n    return sum(p * x for x, p in pmf.Items())\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def PmfMean(pmf):\n",
    "    \"\"\"Computes the mean of a PMF.\n",
    "    Returns:\n",
    "        float mean\n",
    "    \"\"\"\n",
    "    return sum(p * x for x, p in pmf.Items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 40;\n",
       "                var nbb_unformatted_code = \"def PmfVar(pmf, mu=None):\\n    \\\"\\\"\\\"Computes the variance of a PMF.\\n    mu: the point around which the variance is computed;\\n            if omitted, computes the mean\\n    returns: float variance\\n    \\\"\\\"\\\"\\n    if mu is None:\\n        mu = PmfMean(pmf)\\n\\n    return sum(p * (x-mu)**2 for x, p in pmf.Items())\";\n",
       "                var nbb_formatted_code = \"def PmfVar(pmf, mu=None):\\n    \\\"\\\"\\\"Computes the variance of a PMF.\\n    mu: the point around which the variance is computed;\\n            if omitted, computes the mean\\n    returns: float variance\\n    \\\"\\\"\\\"\\n    if mu is None:\\n        mu = PmfMean(pmf)\\n\\n    return sum(p * (x - mu) ** 2 for x, p in pmf.Items())\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def PmfVar(pmf, mu=None):\n",
    "    \"\"\"Computes the variance of a PMF.\n",
    "    mu: the point around which the variance is computed;\n",
    "            if omitted, computes the mean\n",
    "    returns: float variance\n",
    "    \"\"\"\n",
    "    if mu is None:\n",
    "        mu = PmfMean(pmf)\n",
    "\n",
    "    return sum(p * (x - mu) ** 2 for x, p in pmf.Items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Something like the class size paradox appears if you survey children and ask how many children are in their family. Families with many children are more likely to appear in your sample, and families with no children have no chance to be in the sample.\n",
    "\n",
    "Use the NSFG respondent variable `numkdhh` to construct the actual distribution for the number of children under 18 in the respondents' households.\n",
    "\n",
    "Now compute the biased distribution we would see if we surveyed the children and asked them how many children under 18 (including themselves) are in their household.\n",
    "\n",
    "Plot the actual and biased distributions, and compute their means."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemResp.dct\")\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/2002FemResp.dat.gz\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 41;\n",
       "                var nbb_unformatted_code = \"resp = nsfg.ReadFemResp()\";\n",
       "                var nbb_formatted_code = \"resp = nsfg.ReadFemResp()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "resp = nsfg.ReadFemResp()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 42;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\npmf = thinkstats2.Pmf(resp.numkdhh, label='numkdhh')\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\npmf = thinkstats2.Pmf(resp.numkdhh, label=\\\"numkdhh\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "pmf = thinkstats2.Pmf(resp.numkdhh, label=\"numkdhh\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 43;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\nthinkplot.Pmf(pmf)\\nthinkplot.Config(xlabel='Number of children', ylabel='PMF')\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\nthinkplot.Pmf(pmf)\\nthinkplot.Config(xlabel=\\\"Number of children\\\", ylabel=\\\"PMF\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "thinkplot.Pmf(pmf)\n",
    "thinkplot.Config(xlabel=\"Number of children\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 44;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\nbiased = BiasPmf(pmf, label='biased')\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\nbiased = BiasPmf(pmf, label=\\\"biased\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "biased = BiasPmf(pmf, label=\"biased\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 45;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\nthinkplot.PrePlot(2)\\nthinkplot.Pmfs([pmf, biased])\\nthinkplot.Config(xlabel='Number of children', ylabel='PMF')\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\nthinkplot.PrePlot(2)\\nthinkplot.Pmfs([pmf, biased])\\nthinkplot.Config(xlabel=\\\"Number of children\\\", ylabel=\\\"PMF\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "thinkplot.PrePlot(2)\n",
    "thinkplot.Pmfs([pmf, biased])\n",
    "thinkplot.Config(xlabel=\"Number of children\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.024205155043831"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 46;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\npmf.Mean()\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\npmf.Mean()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "pmf.Mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.403679100664282"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 47;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\nbiased.Mean()\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\nbiased.Mean()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "biased.Mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** I started this book with the question, \"Are first babies more likely to be late?\" To address it, I computed the difference in means between groups of babies, but I ignored the possibility that there might be a difference between first babies and others for the same woman.\n",
    "\n",
    "To address this version of the question, select respondents who have at least two live births and compute pairwise differences. Does this formulation of the question yield a different result?\n",
    "\n",
    "Hint: use `nsfg.MakePregMap`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 48;\n",
       "                var nbb_unformatted_code = \"live, firsts, others = first.MakeFrames()\";\n",
       "                var nbb_formatted_code = \"live, firsts, others = first.MakeFrames()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "live, firsts, others = first.MakeFrames()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 49;\n",
       "                var nbb_unformatted_code = \"preg_map = nsfg.MakePregMap(live)\";\n",
       "                var nbb_formatted_code = \"preg_map = nsfg.MakePregMap(live)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "preg_map = nsfg.MakePregMap(live)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 50;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\nhist = thinkstats2.Hist()\\n\\nfor caseid, indices in preg_map.items():\\n    if len(indices) >= 2:\\n        pair = preg.loc[indices[0:2]].prglngth\\n        diff = np.diff(pair)[0]\\n        hist[diff] += 1\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\nhist = thinkstats2.Hist()\\n\\nfor caseid, indices in preg_map.items():\\n    if len(indices) >= 2:\\n        pair = preg.loc[indices[0:2]].prglngth\\n        diff = np.diff(pair)[0]\\n        hist[diff] += 1\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "hist = thinkstats2.Hist()\n",
    "\n",
    "for caseid, indices in preg_map.items():\n",
    "    if len(indices) >= 2:\n",
    "        pair = preg.loc[indices[0:2]].prglngth\n",
    "        diff = np.diff(pair)[0]\n",
    "        hist[diff] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 51;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\nthinkplot.Hist(hist)\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\nthinkplot.Hist(hist)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "thinkplot.Hist(hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.056367432150313125"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 52;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\npmf = thinkstats2.Pmf(hist)\\npmf.Mean()\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\npmf = thinkstats2.Pmf(hist)\\npmf.Mean()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "pmf = thinkstats2.Pmf(hist)\n",
    "pmf.Mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** In most foot races, everyone starts at the same time. If you are a fast runner, you usually pass a lot of people at the beginning of the race, but after a few miles everyone around you is going at the same speed.\n",
    "When I ran a long-distance (209 miles) relay race for the first time, I noticed an odd phenomenon: when I overtook another runner, I was usually much faster, and when another runner overtook me, he was usually much faster.\n",
    "\n",
    "At first I thought that the distribution of speeds might be bimodal; that is, there were many slow runners and many fast runners, but few at my speed.\n",
    "\n",
    "Then I realized that I was the victim of a bias similar to the effect of class size. The race was unusual in two ways: it used a staggered start, so teams started at different times; also, many teams included runners at different levels of ability.\n",
    "\n",
    "As a result, runners were spread out along the course with little relationship between speed and location. When I joined the race, the runners near me were (pretty much) a random sample of the runners in the race.\n",
    "\n",
    "So where does the bias come from? During my time on the course, the chance of overtaking a runner, or being overtaken, is proportional to the difference in our speeds. I am more likely to catch a slow runner, and more likely to be caught by a fast runner. But runners at the same speed are unlikely to see each other.\n",
    "\n",
    "Write a function called `ObservedPmf` that takes a `Pmf` representing the actual distribution of runners’ speeds, and the speed of a running observer, and returns a new `Pmf` representing the distribution of runners’ speeds as seen by the observer.\n",
    "\n",
    "To test your function, you can use `relay.py`, which reads the results from the James Joyce Ramble 10K in Dedham MA and converts the pace of each runner to mph.\n",
    "\n",
    "Compute the distribution of speeds you would observe if you ran a relay race at 7 mph with this group of runners."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/relay.py\")\n",
    "download(\"https://github.com/AllenDowney/ThinkStats2/raw/master/code/Apr25_27thAn_set1.shtml\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 53;\n",
       "                var nbb_unformatted_code = \"import relay\\n\\nresults = relay.ReadResults()\\nspeeds = relay.GetSpeeds(results)\\nspeeds = relay.BinData(speeds, 3, 12, 100)\";\n",
       "                var nbb_formatted_code = \"import relay\\n\\nresults = relay.ReadResults()\\nspeeds = relay.GetSpeeds(results)\\nspeeds = relay.BinData(speeds, 3, 12, 100)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import relay\n",
    "\n",
    "results = relay.ReadResults()\n",
    "speeds = relay.GetSpeeds(results)\n",
    "speeds = relay.BinData(speeds, 3, 12, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 54;\n",
       "                var nbb_unformatted_code = \"pmf = thinkstats2.Pmf(speeds, 'actual speeds')\\nthinkplot.Pmf(pmf)\\nthinkplot.Config(xlabel='Speed (mph)', ylabel='PMF')\";\n",
       "                var nbb_formatted_code = \"pmf = thinkstats2.Pmf(speeds, \\\"actual speeds\\\")\\nthinkplot.Pmf(pmf)\\nthinkplot.Config(xlabel=\\\"Speed (mph)\\\", ylabel=\\\"PMF\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pmf = thinkstats2.Pmf(speeds, \"actual speeds\")\n",
    "thinkplot.Pmf(pmf)\n",
    "thinkplot.Config(xlabel=\"Speed (mph)\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 55;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\ndef ObservedPmf(pmf, speed, label=None):\\n    \\\"\\\"\\\"Returns a new Pmf representing speeds observed at a given speed.\\n\\n    The chance of observing a runner is proportional to the difference\\n    in speed.\\n\\n    Args:\\n        pmf: distribution of actual speeds\\n        speed: speed of the observing runner\\n        label: string label for the new dist\\n\\n    Returns:\\n        Pmf object\\n    \\\"\\\"\\\"\\n    new = pmf.Copy(label=label)\\n    for val in new.Values():\\n        diff = abs(val - speed)\\n        new[val] *= diff\\n    new.Normalize()\\n    return new\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\n\\ndef ObservedPmf(pmf, speed, label=None):\\n    \\\"\\\"\\\"Returns a new Pmf representing speeds observed at a given speed.\\n\\n    The chance of observing a runner is proportional to the difference\\n    in speed.\\n\\n    Args:\\n        pmf: distribution of actual speeds\\n        speed: speed of the observing runner\\n        label: string label for the new dist\\n\\n    Returns:\\n        Pmf object\\n    \\\"\\\"\\\"\\n    new = pmf.Copy(label=label)\\n    for val in new.Values():\\n        diff = abs(val - speed)\\n        new[val] *= diff\\n    new.Normalize()\\n    return new\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "def ObservedPmf(pmf, speed, label=None):\n",
    "    \"\"\"Returns a new Pmf representing speeds observed at a given speed.\n",
    "\n",
    "    The chance of observing a runner is proportional to the difference\n",
    "    in speed.\n",
    "\n",
    "    Args:\n",
    "        pmf: distribution of actual speeds\n",
    "        speed: speed of the observing runner\n",
    "        label: string label for the new dist\n",
    "\n",
    "    Returns:\n",
    "        Pmf object\n",
    "    \"\"\"\n",
    "    new = pmf.Copy(label=label)\n",
    "    for val in new.Values():\n",
    "        diff = abs(val - speed)\n",
    "        new[val] *= diff\n",
    "    new.Normalize()\n",
    "    return new\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 56;\n",
       "                var nbb_unformatted_code = \"# Solution\\n\\nbiased = ObservedPmf(pmf, 7, label='observed speeds')\\nthinkplot.Pmf(biased)\\nthinkplot.Config(xlabel='Speed (mph)', ylabel='PMF')\";\n",
       "                var nbb_formatted_code = \"# Solution\\n\\nbiased = ObservedPmf(pmf, 7, label=\\\"observed speeds\\\")\\nthinkplot.Pmf(biased)\\nthinkplot.Config(xlabel=\\\"Speed (mph)\\\", ylabel=\\\"PMF\\\")\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "biased = ObservedPmf(pmf, 7, label=\"observed speeds\")\n",
    "thinkplot.Pmf(biased)\n",
    "thinkplot.Config(xlabel=\"Speed (mph)\", ylabel=\"PMF\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}