P8 - Python for the Probablity Distribution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ae813bde",
   "metadata": {},
   "source": [
    "Many statistical tools and techniques used in data analysis are based on probability. Probability measures how likely it is for an event to occur on a scale from 0 (the event never occurs) to 1 (the event always occurs). When working with data, variables in the columns of the data set can be thought of as random variables: variables that vary due to chance. A probability distribution describes how a random variable is distributed; it tells us which values a random variable is most likely to take on and which values are less likely.\n",
    "\n",
    "In statistics, there are a range of precisely defined probability distributions that have different shapes and can be used to model different types of random events. In this, we'll discuss some common probability distributions and how to work with them in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aab4ea59",
   "metadata": {},
   "source": [
    "**The Uniform Distribution**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9521b007",
   "metadata": {},
   "source": [
    "The uniform distribution is a probability distribution where each value within a certain range is equally likely to occur and values outside of the range never occur. If we make a density plot of a uniform distribution, it appears flat because no value is any more likely (and hence has any more density) than another.\n",
    "\n",
    "Many useful functions for working with probability distributions in Python are contained in the scipy.stats library. Let's load in some libraries, generate some uniform data and plot a density curve:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ee343c9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "%matplotlib inline \n",
    "import scipy.stats as stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e54dc266",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.21075848, 8.99297501, 8.88253653, ..., 3.74144429, 9.21299728,\n",
       "       1.31461587])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate 10000 numbmers form 0 to 10\n",
    "\n",
    "uniform_data = stats.uniform.rvs(size = 100000,\n",
    "                            loc = 0,\n",
    "                            scale = 10)\n",
    "uniform_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e80a3e95",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the above data into the pandas dataframe \n",
    "\n",
    "uniform_data = pd.DataFrame(uniform_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a877b9dc",
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4.210758</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>8.992975</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8.882537</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>9.782977</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>8.509536</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99995</th>\n",
       "      <td>8.509563</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99996</th>\n",
       "      <td>8.862618</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99997</th>\n",
       "      <td>3.741444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99998</th>\n",
       "      <td>9.212997</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99999</th>\n",
       "      <td>1.314616</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>100000 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              0\n",
       "0      4.210758\n",
       "1      8.992975\n",
       "2      8.882537\n",
       "3      9.782977\n",
       "4      8.509536\n",
       "...         ...\n",
       "99995  8.509563\n",
       "99996  8.862618\n",
       "99997  3.741444\n",
       "99998  9.212997\n",
       "99999  1.314616\n",
       "\n",
       "[100000 rows x 1 columns]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "uniform_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b727862a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:ylabel='Density'>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the data using the density plot \n",
    "\n",
    "uniform_data.plot(kind = 'density',\n",
    "                 figsize = (10,10),\n",
    "                 xlim = (-1,11))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0a8d5be",
   "metadata": {},
   "source": [
    "* In the code above, we generated 100,000 data points from a uniform distribution spanning the range 0 to 10. In the density plot, we see that the density of our uniform data is essentially level, meaning any given value has the same probability of occurring. The area under a probability density curve is always equal to 1."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04c3fc64",
   "metadata": {},
   "source": [
    "Probability distributions in scipy come with several useful functions for generating random data and extracting values of interest:\n",
    "\n",
    "* stats.distribution.rvs() generates random numbers from the specified distribution. The arguments to rvs() will vary depending on the type of distribution you're working with; in the case of the uniform distribution, we have to specify the starting and ending points and the size (number of random points to generate.).\n",
    "\n",
    "* stats.distribution.cdf() is used to determine the probability that an observation drawn from a distribution falls below a specified value (known as the cumulative distribution function). In essence, cdf() gives you the area under the distribution's density curve to the left of a certain value on the x axis. For example, in the uniform distribution above, there is a 25% chance that an observation will be in the range 0 to 2.5 and a 75% chance it will fall in the range 2.5 to 10. We can confirm this with cdf():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b90fd24b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Cut off value to check  quantile\n",
    "\n",
    "stats.uniform.cdf(x = 2.5,\n",
    "                 loc = 0,\n",
    "                 scale = 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07e43cd5",
   "metadata": {},
   "source": [
    "* stats.distribution.ppf() is the inverse of cdf(): it returns the x axis cutoff value (quantile) associated with a given probability. For instance, if we want to know the cutoff value for which we have a 40% chance of drawing an observation below that value, we can use ppf():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7a3589a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.uniform.ppf(q = 0.4,\n",
    "                 loc = 0,\n",
    "                 scale = 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09de21b0",
   "metadata": {},
   "source": [
    "* stats.distribution.pdf() gives us the probability density (height of the distribution) at a given x value. Since the uniform distribution is flat, all x values within its range will have the same probability density and x values outside the range have a probability density of 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "43c61b12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Density at x value -1\n",
      "0.0\n",
      "Density at x value 2\n",
      "0.1\n",
      "Density at x value 5\n",
      "0.1\n",
      "Density at x value 8\n",
      "0.1\n",
      "Density at x value 11\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "for x in range(-1,12,3):\n",
    "    print(\"Density at x value \" + str(x))\n",
    "    print( stats.uniform.pdf(x, loc=0, scale=10) )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c4e519f",
   "metadata": {},
   "source": [
    "Probability distribution functions in scipy also support median(), mean(), var() and std()."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03405919",
   "metadata": {},
   "source": [
    "**Generating Random Numbers and Setting The Seed**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d565871",
   "metadata": {},
   "source": [
    "When we need to generate random real numbers in a range with equal probability we can draw numbers from a uniform distribution using stats.distribution.rvs(). Python also comes with a library called \"random\" that lets you perform various operations that involve randomization. Let's look at a few functions in the random library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "326b1278",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "random.randint(0,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c95c8a5e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.choice([2,3,5,6,8,9,11])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4b40d9d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6112977471594665"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.random() # get a real number between 0 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "58d0bd91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.521685513504306"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.uniform(0,10) #get a real number between the specified range "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5ca22a5",
   "metadata": {},
   "source": [
    "Notice that the random library also lets us generate random uniform numbers. Regardless of the method we use to generate random numbers, however, the result of a random process can differ from one run to the next. Having results vary each time you run a function is often not desirable. For example, if we want a colleague to be able to reproduce our results exactly, we can run into problems when we use randomization. we can ensure that our results are the same each time we use a function that involves randomness by setting the random number generator's seed value to initialize it prior to running the function. Set the random seed with random.seed():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a0aa906d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4.7457067868854805, 6.574725026572553, 6.664104711248381, 1.4260035292536777]\n",
      "[4.7457067868854805, 6.574725026572553, 6.664104711248381, 1.4260035292536777]\n"
     ]
    }
   ],
   "source": [
    "random.seed(12) # set the seed to a arbitrary value \n",
    "\n",
    "print([random.uniform(0,10) for i in range(4)])\n",
    "\n",
    "random.seed(12) # set the seed to the same value \n",
    "\n",
    "print([random.uniform(0,10) for i in range(4)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25f2094a",
   "metadata": {},
   "source": [
    "Notice that we generated the exact same numbers with both calls to random.uniform() because we set the same seed before each call. If we had not set the seed, we would have gotten different numbers. This reproducibility illustrates the fact that these random numbers aren't truly random, but rather \"pseudorandom\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f552586",
   "metadata": {},
   "source": [
    "Many functions in Python's libraries that use randomness have an optional random seed argument built in so that you don't have to set the seed outside of the function. For instance, the rvs() function has an optional argument random_state, that lets you set the seed."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84497458",
   "metadata": {},
   "source": [
    "**The Normal Distribution**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "178ff23f",
   "metadata": {},
   "source": [
    "* The normal or Gaussian distribution is a continuous probability distribution characterized by a symmetric bell-shaped curve. A normal distribution is defined by its center (mean) and spread (standard deviation.). The bulk of the observations generated from a normal distribution lie near the mean, which lies at the exact center of the distribution: \n",
    "* as a rule of thumb, about 68% of the data lies within 1 standard deviation of the mean, 95% lies within 2 standard deviations and 99.7% lies within 3 standard deviations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52f99ddb",
   "metadata": {},
   "source": [
    "The scipy nickname for the normal distribution is norm. Let's investigate the normal distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "4913a56b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.15865525393145707\n",
      "0.6826894921370859\n",
      "0.15865525393145707\n"
     ]
    }
   ],
   "source": [
    "prob_under_minus1 = stats.norm.cdf(x = -1,\n",
    "                                  loc = 0,\n",
    "                                  scale = 1)\n",
    "\n",
    "prob_under_1 = stats.norm.cdf(x = 1,\n",
    "                             loc = 0,\n",
    "                             scale = 1)\n",
    "\n",
    "prob_over_1 = 1 - prob_under_1\n",
    "\n",
    "prob_bw_mminus1_and_1 = 1-(prob_under_minus1 + prob_over_1)\n",
    "\n",
    "print(prob_under_minus1)\n",
    "\n",
    "print(prob_bw_mminus1_and_1)\n",
    "print(prob_over_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e3e9b4e",
   "metadata": {},
   "source": [
    "* The output shows that roughly 16% of the data generated by a normal distribution with mean 0 and standard deviation 1 is below -1, 16% is above 1 and 68% lies between -1 and 1, which agrees with the 68, 95, 99.7 rule. Let's plot the normal distribution and inspect areas we calculated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "47614dc4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(1.3, 0.05, '0.16')"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAn2UlEQVR4nO3deXzV9Z3v8dcnCYHIJkoQZRHQ2IraaieiM871tjMuaB3o3NpbnGsfOmOv46086rTzaEdHRy2dLqPTZcZhqli3qhRxjxplxwUEE7ZAEgIhQBaWrGRPzva5f5wDHkIgJ+Qk39855/N8PPLgnN9yzvsAeeeX728TVcUYY0zySnMdwBhjzOCyojfGmCRnRW+MMUnOit4YY5KcFb0xxiS5DNcBeho/frxOmzbNdQxjjEkomzZtqlfV7N7mea7op02bRmFhoesYxhiTUERk/8nm2dCNMcYkOSt6Y4xJclb0xhiT5KzojTEmyVnRG2NMkoup6EVktoiUiUi5iNx/iuW+KSIqIrlR0x6IrFcmIjfGI7QxxpjY9Xl4pYikAwuB64FqoEBE8lS1pMdyo4H7gI1R02YC84BLgPOAlSJykaoG4/cRjDHGnEosW/SzgHJVrVBVH7AEmNvLcj8F/g3oipo2F1iiqt2quhcoj7yeMcaYIRLLCVOTgKqo59XAVdELiMhXgCmq+p6I/KjHuht6rDup5xuIyN3A3QBTp06NLbkxQyHoh13LYM8qaKwADcG4aTDjq/CFr8OwEa4TGtOnAZ8ZKyJpwK+BO0/3NVR1EbAIIDc31+6EYtxThe2vwaqfQHPV8fP2fgSb/wAjJ8DXHoCv3AlpdlyD8a5Yir4GmBL1fHJk2lGjgUuBtSICMBHIE5E5MaxrjPd0t8Jb34PSvFMv114L7/4ASvLgm8/AyLOHJp8x/RTLZkgBkCMi00Ukk/DO1WPfAararKrjVXWaqk4jPFQzR1ULI8vNE5HhIjIdyAE+i/unMCZe2urguZv6LvloFWvgmeug6aSXGjHGqT6LXlUDwHxgGVAKLFXVYhFZENlqP9W6xcBSoAT4ALjXjrgxntXeAC/cAoe293/dxgp4/hZoro5/LmMGSLx2c/Dc3Fy1q1eaIefvghf+CqoH+Atn9sVw1zIYMTY+uYyJkYhsUtXc3ubZHiRjVOG9Hw685AHqSuGNv4dQaOCvZUycWNEbs/Xl8Fe87HofPn0ifq9nzABZ0ZvU1lgB+T+O/+uu+ikc3Bb/1zXmNFjRm9QVCsHb88HfPgiv7Q8fohn0x/+1jeknK3qTurb8AfavG7zXP7wD1v/n4L2+MTGyojepqb0BVjwy+O/z4WN2fL1xzorepKY1/wpdRwb/fQJdsOJfBv99jDkFK3qTempLYdPzQ/d+JW/D/vVD937G9GBFb1LPykfDV6EcSiseDh+vb4wDVvQmtVRugF0fDP37VhdAWf7Qv68xWNGbVLP6X92995qf2xmzxgkrepM69q2DfR+7e//DO2DnO+7e36QsK3qTOj56zHUC+OhxG6s3Q86K3qSG6k1QsdZ1ivAlkHevcJ3CpBgrepMa1v3WdYLPeSmLSQkxFb2IzBaRMhEpF5H7e5l/j4hsF5GtIvKJiMyMTJ8mIp2R6VtF5Ml4fwBj+tSwB0o9NDa+f134NwxjhkifRS8i6cBC4CZgJnDb0SKPslhVL1PVy4HHCN8s/Kg9qnp55OueOOU2JnYb/hvw2Li4XcbYDKFYtuhnAeWqWqGqPmAJMDd6AVVtiXo6Es99V5mU1dkEWxe7TnGikjw4UuU6hUkRsRT9JCD6f2R1ZNpxROReEdlDeIv++1GzpovIFhH5UET+R29vICJ3i0ihiBTW1dX1I74xfdj8Ivg7XKc4kQah4GnXKUyKiNvOWFVdqKoXAP8EPBSZfBCYqqpXAD8EFovImF7WXaSquaqam52dHa9IJtWFPF6mm/8A/k7XKUwKiKXoa4ApUc8nR6adzBLgGwCq2q2qDZHHm4A9wEWnldSY/tq9HI5Uuk5xcp1NsON11ylMCoil6AuAHBGZLiKZwDwgL3oBEcmJevp1YHdkenZkZy4iMgPIASriEdyYPhU84zpB3wp+7zqBSQEZfS2gqgERmQ8sA9KBZ1W1WEQWAIWqmgfMF5HrAD/QBNwRWf1aYIGI+IEQcI+qNg7GBzHmOE37oHyl6xR9O7Al/HXeFa6TmCTWZ9EDqGo+kN9j2sNRj+87yXqvA/a7qRl6m14gYQ7+KnwO5ljRm8FjZ8aa5BP0w9aXXaeI3Y7XobvVdQqTxKzoTfLZtQzaDrtOETtfG+x4w3UKk8Ss6E3y2fKi6wT9l4iZTcKwojfJpeVg+LDKRFNdALU7XacwScqK3iSXoiVDfz/YeNn6kusEJklZ0ZvkoerN69rEqmgpBAOuU5gkZEVvkkfNZqjf5TrF6Ws7DHtWuU5hkpAVvUke2/7oOsHAJcNnMJ5jRW+SQ8AHO15znWLgduZD5xHXKUySsaI3yaF8RfgiYYku2A0lb7tOYZKMFb1JDkWvuE4QP9tfdZ3AJBkrepP4upqh7APXKeJn38fQXO06hUkiVvQm8ZXkhYc8ksn2JNjfYDzDit4kvmQc6rCiN3FkRW8SW+vh8FBHsjm83S6JYOLGit4ktuI3E/eSB31JhsNFjSfEVPQiMltEykSkXETu72X+PSKyXUS2isgnIjIzat4DkfXKROTGeIY3Jqnvubrj9fBlHYwZoD6LPnLP14XATcBM4LboIo9YrKqXqerlwGPAryPrziR8j9lLgNnAfx+9h6wxA9a0H6o/c51i8DRWwMGtrlOYJBDLFv0soFxVK1TVBywB5kYvoKotUU9H8vk93OYCS1S1W1X3AuWR1zNm4IrfdJ1g8NkNSUwcxFL0k4CqqOfVkWnHEZF7RWQP4S367/dz3btFpFBECuvq6mLNblJdcQqUYPGbNnxjBixuO2NVdaGqXgD8E/BQP9ddpKq5qpqbnZ0dr0gmmTXsgYPbXKcYfM1VUF3oOoVJcLEUfQ0wJer55Mi0k1kCfOM01zUmNqkwbHNUKn1WMyhiKfoCIEdEpotIJuGdq3nRC4hITtTTrwO7I4/zgHkiMlxEpgM5QBLvPTNDpvgt1wmGTslbEErSQ0jNkMjoawFVDYjIfGAZkA48q6rFIrIAKFTVPGC+iFwH+IEm4I7IusUishQoAQLAvaoaHKTPYlJFfXn4hKJU0VIDNYUwxY5jMKenz6IHUNV8IL/HtIejHt93inV/BvzsdAMac4KSFBzKKH7Tit6cNjsz1iSeVLxee0meDd+Y02ZFbxJLwx44lELDNke1VEPNJtcpTIKyojeJJRW35o8qect1ApOgrOhNYknloi/Ns5OnzGmxojeJo2l/al/75Uhlan9+c9qs6E3iKH3HdQL3SvL6XsaYHqzoTeIotZKz4RtzOqzoTWJoOQhVG12ncK+hHGpLXacwCcaK3iSGne+6TuAd9puN6ScrepMYUvlom55snN70kxW98b72Bti/znUK76gtDp84ZkyMrOiN95XlJ+8NwE+XHYFk+sGK3nifldqJbJze9IMVvfG2rhaoWOM6hffUbIJmu4ePiY0VvfG23csh6HOdwpt2vuc6gUkQVvTG2+ywypOz4RsTo5iKXkRmi0iZiJSLyP29zP+hiJSISJGIrBKR86PmBUVka+TL/mea2Pm7YNdy1ym8a//68BFJxvShz6IXkXRgIXATMBO4TURm9lhsC5Crql8CXgMei5rXqaqXR77mxCm3SQUVa8Df7jqFd2kQdr3vOoVJALFs0c8CylW1QlV9wBJgbvQCqrpGVTsiTzcAk+Mb06SkUhu26ZMdkWRiEEvRTwKqop5XR6adzF1A9GbGCBEpFJENIvKN3lYQkbsjyxTW1dXFEMkkvWAgfPy8ObU9a6C71XUK43Fx3RkrIrcDucDjUZPPV9Vc4G+A34rIBT3XU9VFqpqrqrnZ2dnxjGQSVeV66Gx0ncL7gt1QvtJ1CuNxsRR9DTAl6vnkyLTjiMh1wIPAHFXtPjpdVWsif1YAa4ErBpDXpAobtomdHWZp+hBL0RcAOSIyXUQygXnAcUfPiMgVwFOES742avo4ERkeeTweuAYoiVd4k6RU7bDK/mg54DqB8bg+i15VA8B8YBlQCixV1WIRWSAiR4+ieRwYBbza4zDKi4FCEdkGrAF+qapW9ObUfG3QYmd99kdFc4XrCMbDMmJZSFXzgfwe0x6OenzdSdZbD1w2kIAm9dS1dmN7avpndeVqZlw2w3UM41F2ZqzxFFVl5c7avhc0x1lTuYZgKOg6hvEoK3rjKeW1beyta3MdI+E0dDWwpXaL6xjGo6zojacsKz7kOkLCWlW5ynUE41FW9MZTlhUfdh0hYa2uXI2quo5hPMiK3nhGdVMH22uaXcdIWAfaD1DaWOo6hvEgK3rjGbY1P3Ar99tZsuZEVvTGM2x8fuBWV652HcF4kBW98YT6tm4K9tm1bQZqT/Me9jbvdR3DeIwVvfGEFSWHsf2I8WFH35ierOiNJ3yww4Zt4sXG6U1PVvTGuZYuP+v31LuOkTSKG4o52HbQdQzjIVb0xrnVpbX4gzZuE082fGOiWdEb52zYJv5WVtrwjfmcFb1xqsMXYO0uu4hZvG0+vJn6ThsOM2FW9MapD8vq6PKHXMdIOoraMfXmGCt649T7NmwzaOzoG3NUTEUvIrNFpExEykXk/l7m/1BESkSkSERWicj5UfPuEJHdka874hneJLYuf5DVdu35QVNwqIDmbrt2kImh6EUkHVgI3ATMBG4TkZk9FtsC5Krql4DXgMci654FPAJcBcwCHhGRcfGLbxLZJ7vraesOuI6RtAIaYE3VGtcxjAfEskU/CyhX1QpV9QFLgLnRC6jqGlXtiDzdAEyOPL4RWKGqjaraBKwAZscnukl0Nmwz+FbsX+E6gvGAWIp+ElAV9bw6Mu1k7gLe78+6InK3iBSKSGFdXV0MkUyi8wVCrCy1q1UOtk8PfEqrr9V1DONYXHfGisjtQC7weH/WU9VFqpqrqrnZ2XZb6FTwaUUDzZ1+1zGSnj/kZ23VWtcxjGOxFH0NMCXq+eTItOOIyHXAg8AcVe3uz7om9eQX2Sn6Q8WGb0wsRV8A5IjIdBHJBOYBedELiMgVwFOESz76MIplwA0iMi6yE/aGyDSTwgLBEMtLbHx+qKyrWUe7v911DONQn0WvqgFgPuGCLgWWqmqxiCwQkTmRxR4HRgGvishWEcmLrNsI/JTwD4sCYEFkmklhn1Y00NRhwzZDxRfy8WHVh65jGIcyYllIVfOB/B7THo56fN0p1n0WePZ0A5rkk7/dhm2G2vL9y7l5xs2uYxhH7MxYM6QCwZDdG9aBT2o+seGbFGZFb4bUpxUNNLb7XMdIOd3Bbjv6JoVZ0Zsh9Z4dbePMsn12HESqsqI3Q8YfDPFBsR1t48q6mnV28lSKsqI3Q2ZdeT1H7GgbZ3whnw3fpCgrejNk3tlmwzaufbDvA9cRjANW9GZIdAeCdpKUB6w/sN4uXZyCrOjNkPiwrI7WLrsksWuBUMBuHJ6CrOjNkMjbdsB1BBORvze/74VMUrGiN4OuvTvAqlK7k5RXFBwqsBuHpxgrejPoVpYeptMfdB3DRIQ0ZMfUpxgrejPo3t5qwzZeY8M3qcWK3gyqpnYfH+2yu4Z5TVFdEVUtVX0vaJKCFb0ZVO9uP0ggpK5jmF7YVn3qsKI3g+rtLXZDMa96t+JdVO2HcCqIqehFZLaIlIlIuYjc38v8a0Vks4gEROTWHvOCkZuRHLshiUkNVY0dFO5vch3DnMS+ln2UNJa4jmGGQJ9FLyLpwELgJmAmcJuIzOyxWCVwJ7C4l5foVNXLI19zeplvktTbW21r3uve3fOu6whmCMSyRT8LKFfVClX1AUuAudELqOo+VS0CQoOQ0SQgVeUNG7bxvPy9+QRCdsZysoul6CcB0bvnqyPTYjVCRApFZIOIfKM/4Uzi2lbdTEWd3dHI6xq7Gll/YL3rGGaQDcXO2PNVNRf4G+C3InJBzwVE5O7ID4PCujo7FC8ZvLG52nUEE6N39rzjOoIZZLEUfQ0wJer55Mi0mKhqTeTPCmAtcEUvyyxS1VxVzc3Ozo71pY1H+QIhu7ZNAllTtYYWX4vrGGYQxVL0BUCOiEwXkUxgHhDT0TMiMk5EhkcejweuAWw3f5JbvfOw3WAkgXQHu1m+b7nrGGYQ9Vn0qhoA5gPLgFJgqaoWi8gCEZkDICJXikg18C3gKREpjqx+MVAoItuANcAvVdWKPsm9tsmGbRLNW+VvuY5gBlFGLAupaj6Q32Paw1GPCwgP6fRcbz1w2QAzmgRS29rFmjLbz5JottVto6K5ghljZ7iOYgaBnRlr4uqtLTUE7ZIHCent8rddRzCDxIrexI2qsrTQhm0SVd6ePDumPklZ0Zu42Vx5hPLaNtcxzGmq76zn4+qPXccwg8CK3sTNKwWVriOYAXpj9xuuI5hBYEVv4qK1y8872w66jmEG6OOaj6ntsNs+JhsrehMXedsO2O0Ck0BQg7y5+03XMUycWdGbAVNV/viZDdskizd2v0EwZD+0k4kVvRmwoupmdtTYKfTJ4kD7AdYdWOc6hokjK3ozYC9v3O86gomzV8tedR3BxJEVvRmQ5g6/XcAsCX1U8xEH22znerKwojcD8uqmKrr8dr+ZZBPSEK/usq36ZGFFb05bKKS8tMGGbZLV67tfxxf0uY5h4sCK3py2D3fXsa+hw3UMM0gauxpZtm+Z6xgmDqzozWl7ft0+1xHMIHu59GVU7SJ1ic6K3pyWPXVtfLjLLkec7IobitlWt811DDNAVvTmtDy3bq/rCGaIvFjyousIZoBiKnoRmS0iZSJSLiL39zL/WhHZLCIBEbm1x7w7RGR35OuOeAU37jS1++wuUilkZeVKatpivk208aA+i15E0oGFwE3ATOA2EZnZY7FK4E5gcY91zwIeAa4CZgGPiMi4gcc2Lr28cb8dUplCQhri5dKXXccwAxDLFv0soFxVK1TVBywB5kYvoKr7VLUI6PndfyOwQlUbVbUJWAHMjkNu40iXP8gLn9ohlanm9V2v0+Kzy1wkqliKfhJQFfW8OjItFjGtKyJ3i0ihiBTW1dkOPi97a0sNda3drmOYIdYR6GBp2VLXMcxp8sTOWFVdpKq5qpqbnZ3tOo45iWBIeeqjCtcxjCMvlbxEd9B+yCeiWIq+BpgS9XxyZFosBrKu8ZgPdhxib3276xjGkYauBt7a/ZbrGOY0xFL0BUCOiEwXkUxgHpAX4+svA24QkXGRnbA3RKaZBKOqLFxT7jqGcey54ufwh/yuY5h+6rPoVTUAzCdc0KXAUlUtFpEFIjIHQESuFJFq4FvAUyJSHFm3Efgp4R8WBcCCyDSTYNaU1VJy0HbGpbqathreq3jPdQzTTxmxLKSq+UB+j2kPRz0uIDws09u6zwLPDiCjcUxV+Y9VtjVvwp4ueppbZtxCRlpM9WE8wBM7Y423rS2rY1vVEdcxjEdUtlaSvze/7wWNZ1jRm1NSVX6zcpfrGMZjntz2pI3VJxArenNKy0sOU1Td7DqG8Ziq1iryymM9JsO4ZkVvTioYUn61vMx1DONRv9v2OzuuPkFY0ZuTemtLDbsOt7mOYTzqcMdhluxc4jqGiYEVvelVlz9oW/OmT4uKFtHcbUN7XmdFb3r13Lp9HGjuch3DeFyLr4Wni552HcP0wYrenKCutdvOgjUxW7xzMVUtVX0vaJyxojcn+NXyMtq6A65jmAThD/n598J/dx3DnIIVvTnO9upmXim0rTPTP6urVrP+wHrXMcxJWNGbY0Ih5V/e3oGq6yQmEf1i4y/wB+0kKi+yojfHLCmoYqtd6sCcpn0t+3i++HnXMUwv7KpEBoDa1i5++X5pr/M6KzbRuGoRhEKM+vINjL36W8fN76raQdOqp/HV7mX8nB8z8ot/fmxeoKWWhvefINBSh4gw4VuPkjH2nEH9LEPhg/IA933QRTCkfPcrmdz/58NPWGZpsZ9H13YjAl8+J43F3zwDgB+v6OK93QFCCtfPyOA/Zg9HRIb6I9Ba1MrBxQchBOOuHUf2Lcff9Ke9rJ2Diw/SVdXFlP83hbFXjj02z9fgo+bZGgKNARA4/wfnk5mdyVNFT3HjtBuZOmbqUH8ccwpW9AaAn+SV0NJ14g5YDQVpXPE7Jnz7X8kYfTYHX/gBWRdeReb4z7+RM8Zkc/bN/0DLZ2+csH79u79m7J9+m6zpVxDydYKDQou3YEi5N7+TFd8ZyeQxwpVPtzPnCxnMzE4/tszuhiC/+KSbdX83knFZQm17+HbK66sCrKsKUnTPSAD+/LkOPtwf5KvThvZbUUPKgRcPMP1H08k4K4OKn1Qw+orRjJg04tgyw84axuTvTqb+/foT1q9eVM2Ev5rAqEtHEewKHvtB1R3sZsGnC3j6hqed/PAyvbOhG8MHOw7y3vaDvc7zHdxFxpnnMuzMiUj6MEZefC2duzcct0zG2HPInDAd5Pj/Tr76SgiFyJp+BQBpmVmkDRtBovusJsiFZ6UxY1wamenCvEuG8fbO439IPr3Zz71XZjIuK1x2E0aG/24E6AooviB0B8EfVM4ZOfSF2FnRyfBzhpM5IZO0jDTGXjWW1i2txy2TmZ3JiCkjwqGjdNV0QQhGXToKgPQR6aQN//zffuOhjby2+7VB/wwmdrZFn+Ia2rp56K0dJ50faG0gY8znv9Knjx6P72BsZ8wGGmtIGzGS2jd/RuDIYbKmXc6Z//MOJC2975U9rKZVmTLm82KbPEbYWBM8bpldDeEt+GuebScYgke/OpzZF2bwp1My+Nq0DM79VSsKzL8yk4uzh/7vw9/kZ9hZw449zxiXQWdFZ0zr+g75SD8jnconKvHV+Rg1cxTn/O9zkLTPfyL8qvBX/Nl5f8akUZPint30X0xb9CIyW0TKRKRcRO7vZf5wEXklMn+jiEyLTJ8mIp0isjXy9WSc85sBUFX++c3t1Lf5Buf1Q0G6qooZ97W7OPeO3xA4coi27asG5b28JhCC3Y0h1t5xBn/8Zhb/951OjnQp5Y0hSutDVP9wNDU/HM3qfUE+3p9Y5yxoSGnf1c7Eb0/kgkcuwFfno+njpuOWafe389AnDxEMBU/yKmYo9Vn0IpIOLARuAmYCt4nIzB6L3QU0qeqFwG+Af4uat0dVL4983ROn3CYOXimoYlnx4VMukzH6bAItdceeB1vrSR91dkyvnzF6PJnnzAgP+6Slk5VzNb7DewaU2QsmjRaqWkLHnle3KJNGH/+tNHmMMOeiDIalC9PHpXHR2WnsbgjxZqmfqyelMypTGJUp3HRhBp9WD30ZDhs3DH/j54dCBpoCDBs37BRrHL/uiKkjyJyQiaQLo78ymq79J14uo/BwIc8VPxe3zOb0xbJFPwsoV9UKVfUBS4C5PZaZC7wQefwa8Jdie2I8rby2lZ+8U9LncpnnXkSg6QD+I4fQoJ/20o/IuvCqmN4j89wcQl1tBDvCF73q2l9E5vgpA8rtBVdOSmd3Q4i9TSF8QWVJsZ85Xzh+FPQbXxzG2v3hAq/vCLGrIcSMccLUsWl8uD9AIKT4g8qH+wNcPH7od5VlTc+i+3A3vjofoUCI5o3NjL5idGzrzsgi1BEi0BL+TaS9tJ3h55141BHAwi0L2Va3LW65zemJZYx+EhB9qmQ10PM7/dgyqhoQkWbg6GbfdBHZArQAD6nqxz3fQETuBu4GmDrVDssabB2+AN97eTOd/r63JCUtnbOuv4fapQ+Dhhh12fVkZp/PkY9fInNiDmfkXEX3wV3UvfEzQt1tdJZ/RvMniznvu/+NpKUz7mt3cXjJg6BK5sQLGfXlG4fgEw6ujDThv24ewY0vdRBU5e8uz+SSCek8vKaL3PPSmfOFYdx4QTrL9wSYubCN9DR4/PoRnH1GGrfOFFbvDXDZ79oRYPaFGfzVF2Lbko4nSRfOu/089v37PjSkjPsf4xgxaQSH3zhM1vQsxlwxho6KDiqfqCTYHqR1ayu1b9aS8/McJE2Y+O2J7H1sLwBZ52cx7qvjen2fgAb40Yc/YuktSzlzxJlD+AlNNNE+ToMUkVuB2ar63cjz7wBXqer8qGV2RJapjjzfQ/iHQSswSlUbRORPgLeAS1S15WTvl5ubq4WFhQP7VOakVJV/eGUrb2894DrKSd19VTb/vO161zESx/nXMHtMiJq2GtdJTuqa865h4V8uJD3Bd8R7mYhsUtXc3ubF8jtjDRD9+/bkyLRelxGRDGAs0KCq3araAKCqm4A9wEX9i2/i6ZlP9nq65E1yWndgHU9secJ1jJQVS9EXADkiMl1EMoF5QM+bReYBd0Qe3wqsVlUVkezIzlxEZAaQA1TEJ7rprzU7a/l5fu9nvxoz2J7Z8Qzv7HnHdYyU1OcYfWTMfT6wDEgHnlXVYhFZABSqah7wDPCiiJQDjYR/GABcCywQET8QAu5R1cbB+CDm1IoPNDN/8WZCdsEy49Aj6x9h4siJXDnxStdRUkpMJ0ypaj6Q32Paw1GPu4Bv9bLe68DrA8xoBqiqsYM7nyug3WfHNBu3/CE/9625j+dnP89F42wUd6jYJRCS3OGWLm5/ZiN1rd2uoxgDQKuvlb9f8fdUtlS6jpIyrOiTWG1rF3/z9Ab2N3S4jmLMceo76/nu8u9S3VrtOkpKsKJPUoeau5i3aAN76tpdRzGmVwfbD/K3y/6W/S37XUdJelb0SWhvfTu3PrmeCit543GH2g9xx/t3sLNxp+soSc2KPslsrmzim79bT3VTbFciNMa1hq4G7vzgTtbX2D1nB4sVfRJ5c0s18xZtoLF9cK5Gacxgafe3871V32Nx6WL6Olvf9J8VfRLwBUI8mlfMD17Zhi8Q6nsFYzwoqEF+8dkveGjdQ3T47QCCeLKiT3AVdW3c+uR6nl+/z3UUY+Iib08et713G2WNsd3gxvTNij5BhULK8+v2cvN/fkxRdbPrOMbEVUVzBfPem8eiokX4Q/6+VzCnZEWfgIoPNPPNJ9fz6DsldPltqMYkp0AowBNbnmDeu/PYWrvVdZyEZveMTSC1LV38ZuVuXimotGvWmJSxq2kX33n/O9w8/Wa+/5Xv231oT4MVfQKoa+3m9x9X8MKn+2wL3qSs/L35LN+/nFtzbuWuy+5i4siJriMlDCt6DyuvbeW5dft4bVM13XY0jTEEQgGWlC3htV2vcfOMm7n94tu5+OyLXcfyPCt6j2nvDrCs+BCvFFSxca9d0dmY3gQ0QN6ePPL25PGl8V/ir3P+mhum3cCYzDGuo3mSFb0HNHf6+XBXHct2HGLVzsM2PGNMPxTVF1FUX8TPN/6cayZdw3VTr+PaydcybkTv97FNRVb0DnT6gmytOsLGvQ2sK69nc+URgrZ31ZgB8Yf8rK1ay9qqtQjCpeMv5epzryb3nFy+POHLjBw20nVEZ2IqehGZDfwH4TtM/V5Vf9lj/nDgD8CfAA3At1V1X2TeA8BdQBD4vqoui1v6BNDU7mN3bRtlh1ooOdhCUXUzOw+1WrEbM4gUZXv9drbXb+fp7U+TJmlccOYFXHL2JXzxrC+Sc2YOF5x5AWeNOAsRcR130PVZ9JF7vi4ErgeqgQIRyVPVkqjF7gKaVPVCEZkH/BvwbRGZSfi2gpcA5wErReQiVU2KWx11+YM0tvuob+vmcEs3h1q6OHikk5ojnVQ2drCvvp2mDjvZwxjXQhpid9NudjftPm766MzRnD/6fCaPnsy5o87l3JHnMuGMCUzImsDZWWczbsQ4sjKyHKWOn1i26GcB5apaASAiS4C5QHTRzwUejTx+DfgvCf+YnAssUdVuYG/knrKzgE/jE/94vkCItu4AqkpQlVAIQqoEQ0pIlUBICYUUf1AJhEL4g4o/GMIfDOELhL+6AyG6/EE6j375grR3B2nr9tPaFaC1K0Bzp5+mDh8dfdyaT0Q4a2TmYHzUpJaVmQFnnO06RuIYPoaxw9WuD3OaatpqqGmrOen8rIwsxg4fy5jMMYzOHM2ozFGMGjaKrIwszhh2BlkZWQxPH37c17C0YQxLHxb+M20Y6WnpZEjGsT/T0tJIl3QEIT0t/GeapHHm8DMH5TeMWIp+ElAV9bwauOpky0RuJt4MnB2ZvqHHuiec7SAidwN3A0ydOjXW7CfIzEjjrAwr1qTw9QrXCRLKK64DGE/zxCUQVHWRquaqam52drbrOMYYk1RiKfoaYErU88mRab0uIyIZwFjCO2VjWdcYY8wgiqXoC4AcEZkuIpmEd67m9VgmD7gj8vhWYLWG7x6QB8wTkeEiMh3IAT6LT3RjjDGx6HOMPjLmPh9YRvjwymdVtVhEFgCFqpoHPAO8GNnZ2kj4hwGR5ZYS3nEbAO5NliNujDEmUYjXbtuVm5urhYWFrmMYY0xCEZFNqprb2zxP7Iw1xhgzeKzojTEmyVnRG2NMkrOiN8aYJOe5nbEiUgfsH8BLjAfq4xQnnixX/1iu/rFc/ZOMuc5X1V7POPVc0Q+UiBSebM+zS5arfyxX/1iu/km1XDZ0Y4wxSc6K3hhjklwyFv0i1wFOwnL1j+XqH8vVPymVK+nG6I0xxhwvGbfojTHGRLGiN8aYJJe0RS8i/ygiKiLjXWc5SkR+KiJFIrJVRJaLyHmuMwGIyOMisjOS7U0ROdN1JgAR+ZaIFItISEScHwonIrNFpExEykXkftd5AETkWRGpFZEdrrNEE5EpIrJGREoi/4b3uc4EICIjROQzEdkWyfUT15miiUi6iGwRkXfj+bpJWfQiMgW4Aah0naWHx1X1S6p6OfAu8LDjPEetAC5V1S8Bu4AHHOc5agfwv4CPXAcRkXRgIXATMBO4TURmuk0FwPPAbNchehEA/lFVZwJXA/d65O+rG/gLVf0ycDkwW0SudhvpOPcBpfF+0aQseuA3wI8BT+1pVtWWqKcj8Ug+VV2uqoHI0w2E7wTmnKqWqmqZ6xwRs4ByVa1QVR+wBJjrOBOq+hHhe0B4iqoeVNXNkcethMvrhPtFDzUNa4s8HRb58sT3oYhMBr4O/D7er510RS8ic4EaVd3mOktvRORnIlIF/B+8s0Uf7e+A912H8KBJQFXU815vdG9OJCLTgCuAjY6jAMeGR7YCtcAKVfVELuC3hDdQQ/F+4T7vMOVFIrISmNjLrAeBfyY8bOPEqbKp6tuq+iDwoIg8AMwHHvFCrsgyDxL+lfvlocgUay6TuERkFPA68A89fqN1JnKXu8sj+6LeFJFLVdXpPg4RuQWoVdVNIvLVeL9+Qha9ql7X23QRuQyYDmwTEQgPQWwWkVmqeshltl68DOQzREXfVy4RuRO4BfhLHcKTK/rx9+Wa3ei+n0RkGOGSf1lV33CdpydVPSIiawjv43C9M/saYI6I3AyMAMaIyEuqens8Xjyphm5UdbuqTlDVaao6jfCv118ZqpLvi4jkRD2dC+x0lSWaiMwm/CvjHFXtcJ3HowqAHBGZLiKZhO+LnOc4k2dJeEvrGaBUVX/tOs9RIpJ99KgyEckCrscD34eq+oCqTo701jxgdbxKHpKs6BPAL0Vkh4gUER5e8sQhZ8B/AaOBFZFDP590HQhARP5aRKqBPwXeE5FlrrJEdlbPB5YR3rG4VFWLXeU5SkT+CHwKfEFEqkXkLteZIq4BvgP8ReT/1NbI1qpr5wJrIt+DBYTH6ON6KKMX2SUQjDEmydkWvTHGJDkremOMSXJW9MYYk+Ss6I0xJslZ0RtjTJKzojfGmCRnRW+MMUnu/wP5rO4TJgZt0QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# PLot the normal distribution area  \n",
    "\n",
    "x1 = np.arange(-4,-1,0.01)\n",
    "y1 = stats.norm.pdf(x1)\n",
    "\n",
    "x2 = np.arange(-1,1,0.01)\n",
    "y2 = stats.norm.pdf(x2)\n",
    "\n",
    "x3 = np.arange(1,4,0.01)\n",
    "y3 = stats.norm.pdf(x3)\n",
    "\n",
    "plt.fill_between(x1,y1)\n",
    "plt.fill_between(x2,y2)\n",
    "plt.fill_between(x3,y3)\n",
    "\n",
    "plt.text(x=-1.8,y = 0.05,\n",
    "        s = round(prob_under_minus1,2))\n",
    "plt.text(x=0,y = 0.05,\n",
    "        s = round(prob_bw_mminus1_and_1,2))\n",
    "plt.text(x= 1.3,y = 0.05,\n",
    "        s = round(prob_over_1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d347c6b1",
   "metadata": {},
   "source": [
    ". Finding quantiles of the normal distribution is a common task when performing statistical tests. we can check normal distribution quantiles with stats.norm.ppf():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "35f66f70",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9599639845400545"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.norm.ppf(q = 0.025) # finding the quantile for the 2.5% cutoff "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "c967d172",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.959963984540054"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.norm.ppf(q = 0.975) # finding the quantile for the 97.5% cutoff"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "209b1d34",
   "metadata": {},
   "source": [
    "* Note: a mean of 0 and standard deviation of 1 are default values for the normal distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de65dd4d",
   "metadata": {},
   "source": [
    "**The Binomial Distribution**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfc1bcdf",
   "metadata": {},
   "source": [
    "The binomial distribution is a discrete probability distribution that models the outcomes of a given number of random trails of some experiment or event. The binomial is defined by two parameters: the probability of success in any given trial and the number of trials. The binomial distribution tells you how likely it is to achieve a given number of successes in n trials of the experiment. For example, we could model flipping a fair coin 10 times with a binomial distribution where the number of trials is set to 10 and the probability of success is set to 0.5. In this case the distribution would tell us how likely it is to get zero heads, 1 head, 2 heads and so on.\n",
    "\n",
    "The scipy name for the binomial is binom. Let's generate and investigate some binomial data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "aed20393",
   "metadata": {},
   "outputs": [],
   "source": [
    "fair_coin_flips = stats.binom.rvs(n=10,        # Number of flips per trial\n",
    "                                  p=0.5,       # Success probability\n",
    "                                  size=10000)  # Number of trials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "9bff8997",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "col_0   0    1    2     3     4     5     6     7    8   9   10\n",
      "row_0                                                          \n",
      "counts   7  104  445  1212  2046  2456  2042  1153  430  96   9\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEICAYAAACzliQjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAARzklEQVR4nO3dfYxldX3H8fenrFpErRDsBGHT4Y/VBt0IZgJUmmZaWuSh6WLSEKiVBTFrWmi12aRZTROM1IQ/RKuJJVl1K7YUShTjRjbiljox/gHyIMqT6AYX2e3CaqHoYqId++0f96zcrrs7M3fv3Lt3fu9XMrnnfs/T95ed+dwz55w5m6pCktSGXxt3A5Kk0TH0Jakhhr4kNcTQl6SGGPqS1BBDX5IaYuhLUkMMfWmJkpyQ5AtJXkjyZJI/G3dP0mKtGncD0gT6BPBzYAo4Hbgjybeq6pGxdiUtQvyLXGnxkhwHPAe8saq+29X+GdhdVZvG2py0CJ7ekZbmdcD8/sDvfAt4w5j6kZbE0JeW5hXAjw+oPQ+8cgy9SEtm6EtLsw941QG1VwE/GUMv0pIZ+tLSfBdYlWRNX+1NgBdxNRG8kCstUZJbgQLeRe/unW3AW7x7R5PAI31p6f4SOBbYC9wC/IWBr0nhkb4kNcQjfUlqiKEvSQ0x9CWpIYa+JDXkqH7g2oknnljT09Mj3+8LL7zAcccdN/L9joJjm1wreXyObbjuv//+H1XVaw4276gO/enpae67776R73dubo7Z2dmR73cUHNvkWsnjc2zDleTJQ83z9I4kNcTQl6SGLBj6SVYn+WqSR5M8kuQ9Xf0DSXYnebD7urBvnfcl2ZHk8SRv7auf39V2JPHZ45I0Yos5pz8PbKyqB5K8Erg/yfZu3ker6sP9Cyc5DbiU3vPFXwv8e5LXdbM/AfwRsAu4N8nWqnp0GAORJC1swdCvqj3Anm76J0keA04+zCrrgFur6mfA95PsAM7s5u2oqifglw+tWgcY+pI0Iku6eyfJNHAGcA9wDnBNksuB++j9NvAcvQ+Eu/tW28WLHxJPHVA/6yD72ABsAJiammJubm4pLQ7Fvn37xrLfUXBsk2slj8+xjc6iQz/JK4DPA++tqh8nuRG4jt4jZq8DbgDeeaQNVdVmYDPAzMxMjeM2Lm8fm0wreWywssfn2EZnUaGf5CX0Av/mqrodoKqe6Zv/SeBL3dvdwOq+1U/pahymLkkagcXcvRPg08BjVfWRvvpJfYu9DXi4m94KXJrkZUlOBdYA3wDuBdYkOTXJS+ld7N06nGFIkhZjMUf65wDvAB5K8mBXez9wWZLT6Z3e2Qm8G6CqHklyG70LtPPA1VX1C4Ak1wB3AscAW/yPJ3Q0mN50x0j3t/P6i0a6P6nfYu7e+TqQg8zadph1PgR86CD1bYdbT5K0vPyLXElqiKEvSQ0x9CWpIYa+JDXE0Jekhhj6ktQQQ1+SGmLoS1JDDH1JaoihL0kNMfQlqSGGviQ1xNCXpIYY+pLUEENfkhpi6EtSQwx9SWqIoS9JDTH0Jakhhr4kNcTQl6SGGPqS1BBDX5IaYuhLUkMMfUlqiKEvSQ0x9CWpIYa+JDXE0Jekhhj6ktQQQ1+SGmLoS1JDVo27AelA05vuGGi9jWvnuWLAdaVWLBj6SVYDnwWmgAI2V9XHkpwA/BswDewELqmq55IE+BhwIfBT4IqqeqDb1nrg77pN/31V3TTc4UhHv1F+qO28/qKB9qWVazGnd+aBjVV1GnA2cHWS04BNwF1VtQa4q3sPcAGwpvvaANwI0H1IXAucBZwJXJvk+CGORZK0gAVDv6r27D9Sr6qfAI8BJwPrgP1H6jcBF3fT64DPVs/dwKuTnAS8FdheVc9W1XPAduD8YQ5GknR4Szqnn2QaOAO4B5iqqj3drKfpnf6B3gfCU32r7epqh6ofuI8N9H5DYGpqirm5uaW0OBT79u0by35HYRLGtnHt/EDrTR07+LqTYJDxHe3/1vtNwvfloI62sS069JO8Avg88N6q+nHv1H1PVVWSGkZDVbUZ2AwwMzNTs7Ozw9jskszNzTGO/Y7CJIxt0IuxG9fOc8NDK/fehEHGt/Pts8vTzJBNwvfloI62sS3qls0kL6EX+DdX1e1d+ZnutA3d696uvhtY3bf6KV3tUHVJ0ogsGPrd3TifBh6rqo/0zdoKrO+m1wNf7Ktfnp6zgee700B3AuclOb67gHteV5Mkjchiflc8B3gH8FCSB7va+4HrgduSXAU8CVzSzdtG73bNHfRu2bwSoKqeTXIdcG+33Aer6tlhDEKStDgLhn5VfR3IIWafe5DlC7j6ENvaAmxZSoOSpOHxMQyS1BBDX5IaYuhLUkMMfUlqiKEvSQ0x9CWpIYa+JDXE0Jekhhj6ktQQQ1+SGmLoS1JDDH1JaoihL0kNMfQlqSGGviQ1xNCXpIYY+pLUEENfkhpi6EtSQwx9SWqIoS9JDTH0Jakhhr4kNcTQl6SGGPqS1BBDX5IaYuhLUkMMfUlqiKEvSQ0x9CWpIYa+JDXE0Jekhhj6ktSQBUM/yZYke5M83Ff7QJLdSR7svi7sm/e+JDuSPJ7krX3187vajiSbhj8USdJCFnOk/xng/IPUP1pVp3df2wCSnAZcCryhW+cfkxyT5BjgE8AFwGnAZd2ykqQRWrXQAlX1tSTTi9zeOuDWqvoZ8P0kO4Azu3k7quoJgCS3dss+uvSWJUmDWjD0D+OaJJcD9wEbq+o54GTg7r5ldnU1gKcOqJ91sI0m2QBsAJiammJubu4IWhzMvn37xrLfUZiEsW1cOz/QelPHDr7uJBhkfEf7v/V+k/B9OaijbWyDhv6NwHVAda83AO8cRkNVtRnYDDAzM1Ozs7PD2OySzM3NMY79jsIkjO2KTXcMtN7GtfPc8NCRHMcc3QYZ3863zy5PM0M2Cd+XgzraxjbQT0hVPbN/OskngS91b3cDq/sWPaWrcZi6JGlEBrplM8lJfW/fBuy/s2crcGmSlyU5FVgDfAO4F1iT5NQkL6V3sXfr4G1Lkgax4JF+kluAWeDEJLuAa4HZJKfTO72zE3g3QFU9kuQ2ehdo54Grq+oX3XauAe4EjgG2VNUjwx6MJOnwFnP3zmUHKX/6MMt/CPjQQerbgG1L6k6SNFT+Ra4kNcTQl6SGGPqS1BBDX5IaYuhLUkMMfUlqiKEvSQ0x9CWpIYa+JDXE0Jekhhj6ktQQQ1+SGmLoS1JDDH1JaoihL0kNMfQlqSGGviQ1xNCXpIYY+pLUkAX/j1wJYHrTHeNuQdIQeKQvSQ0x9CWpIYa+JDXE0JekhnghV1rBRn0Bfuf1F410f1o6j/QlqSGGviQ1xNCXpIYY+pLUEENfkhpi6EtSQwx9SWqIoS9JDVkw9JNsSbI3ycN9tROSbE/yve71+K6eJB9PsiPJt5O8uW+d9d3y30uyfnmGI0k6nMUc6X8GOP+A2ibgrqpaA9zVvQe4AFjTfW0AboTehwRwLXAWcCZw7f4PCknS6CwY+lX1NeDZA8rrgJu66ZuAi/vqn62eu4FXJzkJeCuwvaqerarngO386geJJGmZDfrsnamq2tNNPw1MddMnA0/1Lberqx2q/iuSbKD3WwJTU1PMzc0N2OLg9u3bN5b9jsKgY9u4dn74zQzZ1LGT0eegJmF8g/7c+DM3Okf8wLWqqiQ1jGa67W0GNgPMzMzU7OzssDa9aHNzc4xjv6Mw6NiumID/OWvj2nlueGjlPkNwEsa38+2zA63nz9zoDHr3zjPdaRu6171dfTewum+5U7raoeqSpBEaNPS3AvvvwFkPfLGvfnl3F8/ZwPPdaaA7gfOSHN9dwD2vq0mSRmjB3xWT3ALMAicm2UXvLpzrgduSXAU8CVzSLb4NuBDYAfwUuBKgqp5Nch1wb7fcB6vqwIvDkqRltmDoV9Vlh5h17kGWLeDqQ2xnC7BlSd1JkobKv8iVpIYY+pLUEENfkhpi6EtSQwx9SWqIoS9JDTH0Jakhhr4kNcTQl6SGGPqS1BBDX5IaYuhLUkMMfUlqiKEvSQ0x9CWpIYa+JDXE0Jekhhj6ktQQQ1+SGmLoS1JDDH1JaoihL0kNMfQlqSGGviQ1xNCXpIYY+pLUEENfkhpi6EtSQwx9SWqIoS9JDTH0Jakhhr4kNcTQl6SGHFHoJ9mZ5KEkDya5r6udkGR7ku91r8d39ST5eJIdSb6d5M3DGIAkafGGcaT/+1V1elXNdO83AXdV1Rrgru49wAXAmu5rA3DjEPYtSVqC5Ti9sw64qZu+Cbi4r/7Z6rkbeHWSk5Zh/5KkQzjS0C/gK0nuT7Khq01V1Z5u+mlgqps+GXiqb91dXU2SNCKrjnD9362q3Ul+E9ie5Dv9M6uqktRSNth9eGwAmJqaYm5u7ghbXLp9+/aNZb+jMOjYNq6dH34zQzZ17GT0OahJGN+gPzf+zI3OEYV+Ve3uXvcm+QJwJvBMkpOqak93+mZvt/huYHXf6qd0tQO3uRnYDDAzM1Ozs7NH0uJA5ubmGMd+R2HQsV2x6Y7hNzNkG9fOc8NDR3occ/SahPHtfPvsQOv5Mzc6A5/eSXJcklfunwbOAx4GtgLru8XWA1/sprcCl3d38ZwNPN93GkiSNAJHctgwBXwhyf7t/GtVfTnJvcBtSa4CngQu6ZbfBlwI7AB+Clx5BPuWJA1g4NCvqieANx2k/l/AuQepF3D1oPvT/zc94OmWjWvnJ+JUjaTl4V/kSlJDju6rQpImyqh/A915/UUD7a9lHulLUkMMfUlqiKEvSQ0x9CWpIYa+JDXE0Jekhhj6ktQQQ1+SGmLoS1JDDH1JaoihL0kNMfQlqSGGviQ1xNCXpIYY+pLUEENfkhpi6EtSQwx9SWqIoS9JDTH0Jakhhr4kNcTQl6SGGPqS1BBDX5IaYuhLUkMMfUlqyKpxN7BSTG+6Y9wtSNKCDH1JE2uUB1s7r79oZPtaTp7ekaSGGPqS1BBDX5IaYuhLUkNGHvpJzk/yeJIdSTaNev+S1LKRhn6SY4BPABcApwGXJTltlD1IUstGfcvmmcCOqnoCIMmtwDrg0eXY2aC3c21cO88V3ncvqc+o82S5bhFNVS3Lhg+6s+RPgfOr6l3d+3cAZ1XVNX3LbAA2dG9fDzw+sgZfdCLwozHsdxQc2+RayeNzbMP1W1X1moPNOOr+OKuqNgObx9lDkvuqamacPSwXxza5VvL4HNvojPpC7m5gdd/7U7qaJGkERh369wJrkpya5KXApcDWEfcgSc0a6emdqppPcg1wJ3AMsKWqHhllD4s01tNLy8yxTa6VPD7HNiIjvZArSRov/yJXkhpi6EtSQwz9Piv1ERFJVif5apJHkzyS5D3j7mnYkhyT5JtJvjTuXoYtyauTfC7Jd5I8luR3xt3TsCT5m+578uEktyT59XH3dCSSbEmyN8nDfbUTkmxP8r3u9fhx9mjod1b4IyLmgY1VdRpwNnD1Chrbfu8BHht3E8vkY8CXq+q3gTexQsaZ5GTgr4GZqnojvZs7Lh1vV0fsM8D5B9Q2AXdV1Rrgru792Bj6L/rlIyKq6ufA/kdETLyq2lNVD3TTP6EXGiePt6vhSXIKcBHwqXH3MmxJfgP4PeDTAFX186r677E2NVyrgGOTrAJeDvznmPs5IlX1NeDZA8rrgJu66ZuAi0fZ04EM/RedDDzV934XKygY90syDZwB3DPmVobpH4C/Bf53zH0sh1OBHwL/1J2++lSS48bd1DBU1W7gw8APgD3A81X1lfF2tSymqmpPN/00MDXOZgz9hiR5BfB54L1V9eNx9zMMSf4Y2FtV94+7l2WyCngzcGNVnQG8wJhPDwxLd257Hb0PttcCxyX58/F2tbyqd4/8WO+TN/RftKIfEZHkJfQC/+aqun3c/QzROcCfJNlJ75TcHyT5l/G2NFS7gF1Vtf83s8/R+xBYCf4Q+H5V/bCq/ge4HXjLmHtaDs8kOQmge907zmYM/Ret2EdEJAm9c8KPVdVHxt3PMFXV+6rqlKqapvdv9h9VtWKOFqvqaeCpJK/vSueyTI8iH4MfAGcneXn3PXouK+Qi9QG2Auu76fXAF8fYy9H3lM1xmaBHRAziHOAdwENJHuxq76+qbeNrSUvwV8DN3cHIE8CVY+5nKKrqniSfAx6gd4fZNznKHlmwVEluAWaBE5PsAq4FrgduS3IV8CRwyfg69DEMktQUT+9IUkMMfUlqiKEvSQ0x9CWpIYa+JDXE0Jekhhj6ktSQ/wMdCT1G16SGdgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df= pd.crosstab(index = 'counts',\n",
    "           columns = fair_coin_flips)\n",
    "\n",
    "# convert it into the pandas dataframe \n",
    "print( pd.crosstab(index=\"counts\", columns= fair_coin_flips))\n",
    "\n",
    "pd.DataFrame(fair_coin_flips).hist(range=(-0.5,10.5), bins=11);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "692d5f53",
   "metadata": {},
   "source": [
    "Note that since the binomial distribution is discrete, it only takes on integer values so we can summarize binomial data with a frequency table and its distribution with a histogram. The histogram shows us that a binomial distribution with a 50% probability of success is roughly symmetric, with the most likely outcomes lying at the center. This is reminiscent of the normal distribution, but if we alter the success probability, the distribution won't be symmetric:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "086883f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "col_0   2   3   4    5    6     7     8     9     10\n",
      "row_0                                               \n",
      "counts   1   4  61  279  841  2018  3027  2643  1126\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "biased_coin_flips = stats.binom.rvs(n=10,      # Number of flips per trial\n",
    "                                  p=0.8,       # Success probability\n",
    "                                  size=10000)  # Number of trials\n",
    "\n",
    "# Print table of counts\n",
    "print( pd.crosstab(index=\"counts\", columns= biased_coin_flips))\n",
    "\n",
    "# Plot histogram\n",
    "pd.DataFrame(biased_coin_flips).hist(range=(-0.5,10.5), bins=11);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d95af357",
   "metadata": {},
   "source": [
    "The cdf() function lets us check the probability of achieving a number of successes within a certain range:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "0a2eef67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03279349759999997"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.binom.cdf(k = 5,  # Probablity of k=5 or less\n",
    "               n = 10,  # with 10 flips\n",
    "               p = 0.8)  # success probablity is 0.8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a0561bd",
   "metadata": {},
   "source": [
    "For continuous probability density functions, we use pdf() to check the probability density at a given x value. For discrete distributions like the binomial, use stats.distribution.pmf() (probability mass function) to check the mass (proportion of observations) at given number of successes k:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "1331ca05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30198988799999993"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.binom.pmf(k = 8, # probablity of k=8\n",
    "               n = 10, # with 10 flips \n",
    "               p = 0.8) #success probablity is 0.8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fbf3c10",
   "metadata": {},
   "source": [
    "**The Poisson Distribution**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31b177a9",
   "metadata": {},
   "source": [
    "The Poisson distribution models the probability of seeing a certain number of successes within a time interval, where the time it takes for the next success is modeled by an exponential distribution. The Poisson distribution can be used to model traffic, such as the number of arrivals a hospital can expect in a hour's time or the number of emails you'd expect to receive in a week.\n",
    "\n",
    "The scipy name for the Poisson distribution is \"poisson\". Let's generate and plot some data from a Poisson distribution with an arrival rate of 1 per time unit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "c971a8a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(12)\n",
    "\n",
    "arrival_rate_1 = stats.poisson.rvs(size = 10000, # generate poisson data\n",
    "                                  mu = 1 )# average arrival rate is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "5e0f426c",
   "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>col_0</th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>row_0</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>counts</th>\n",
       "      <td>3653</td>\n",
       "      <td>3709</td>\n",
       "      <td>1850</td>\n",
       "      <td>614</td>\n",
       "      <td>138</td>\n",
       "      <td>28</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "col_0      0     1     2    3    4   5  6  7\n",
       "row_0                                       \n",
       "counts  3653  3709  1850  614  138  28  7  1"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.crosstab(index = 'counts',\n",
    "            columns = arrival_rate_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "88202cae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<AxesSubplot:title={'center':'0'}>]], dtype=object)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.DataFrame(arrival_rate_1)\n",
    "df.hist(range = (-0.5,max(arrival_rate_1)+0.5),\n",
    "       bins = max(arrival_rate_1)+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca61bf9a",
   "metadata": {},
   "source": [
    "* The histogram shows that when arrivals are relatively infrequent, it is rare to see more than a couple of arrivals in each time period. When the arrival rate is high, it becomes increasingly rare to see a low number of arrivals and the distribution starts to look more symmetric:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21e0a35b",
   "metadata": {},
   "source": [
    "As with other discrete probability distributions, we can use cdf() to check the probability of achieving more or less than a certain number of successes and pmf() to check the probability of obtaining a specific number of successes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "d64ad369",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.06708596287903189"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the probablity of 5 arrivals or less with arrival rate 10\n",
    "\n",
    "stats.poisson.cdf(k = 5,\n",
    "                 mu = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "7141c1a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.12511003572113372"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the probablity of exactly 10 arrivals with the arrival rate 10\n",
    "\n",
    "stats.poisson.pmf(k = 10,\n",
    "                 mu = 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81ded938",
   "metadata": {},
   "source": [
    "* Probability distribution functions are useful for generating random data, modeling random events and aiding with statistical tests and analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4c450dc",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}