student.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libraries \n",
    "import pandas as pd  \n",
    "import numpy as np\n",
    "import sqlite3  \n",
    "import statsmodels.api as sm\n",
    "from statsmodels.formula.api import ols \n",
    "from scipy import stats\n",
    "from statsmodels.stats.power import TTestIndPower, TTestPower \n",
    "\n",
    "import seaborn as sns \n",
    "import matplotlib.pyplot as plt \n",
    "%matplotlib inline \n",
    "sns.set_style('darkgrid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bootstrap(A, B):\n",
    "    universe = list(A) + list(B)\n",
    "    universe_shuffled = np.random.choice(universe, size=len(universe), replace=True)\n",
    "    new_a = universe_shuffled[:len(A)]\n",
    "    new_b = universe_shuffled[len(A):]\n",
    "    return new_a, new_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_sample_ttest(sample, popmean, alpha):\n",
    "\n",
    "    # Visualize sample distribution for normality \n",
    "    sns.set(color_codes=True)\n",
    "    sns.set(rc={'figure.figsize':(12,10)})\n",
    "    sns.distplot(sample)\n",
    "    \n",
    "    # Population mean \n",
    "    mu = popmean\n",
    "    \n",
    "    # Sample mean (x̄) using NumPy mean()\n",
    "    x_bar= sample.mean()\n",
    "\n",
    "    # Sample Standard Deviation (sigma) using Numpy\n",
    "    sigma = np.std(sample)\n",
    "    \n",
    "    # Degrees of freedom\n",
    "    df = len(sample) - 1\n",
    "    \n",
    "    #Calculate the critical t-value\n",
    "    t_crit = stats.t.ppf(1 - alpha, df=df)\n",
    "    \n",
    "    #Calculate the t-value and p-value\n",
    "    results = stats.ttest_1samp(a= sample, popmean= mu)         \n",
    "    \n",
    "    if (results[0]>t_crit) and (results[1]<alpha):\n",
    "        print (\"Null hypothesis rejected. Results are statistically significant with t-value =\", \n",
    "                round(results[0], 2), \"critical t-value =\", t_crit, \"and p-value =\", np.round((results[1]), 10))\n",
    "    else:\n",
    "        print (\"Null hypothesis is True with t-value =\", \n",
    "                round(results[0], 2), \", critical t-value =\", t_crit, \"and p-value =\", np.round((results[1]), 10))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [],
   "source": [
    "def welch_t(a, b):\n",
    "    \n",
    "    \"\"\" Calculate Welch's t-statistic for two samples. \"\"\"\n",
    "\n",
    "    numerator = a.mean() - b.mean()\n",
    "    \n",
    "    # “ddof = Delta Degrees of Freedom”: the divisor used in the calculation is N - ddof, \n",
    "    #  where N represents the number of elements. By default ddof is zero.\n",
    "    \n",
    "    denominator = np.sqrt(a.var(ddof=1)/a.size + b.var(ddof=1)/b.size)\n",
    "    \n",
    "    return np.abs(numerator/denominator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [],
   "source": [
    "def welch_df(a, b):\n",
    "    \n",
    "    \"\"\" Calculate the effective degrees of freedom for two samples. \"\"\"\n",
    "    \n",
    "    s1 = a.var(ddof=1) \n",
    "    s2 = b.var(ddof=1)\n",
    "    n1 = a.size\n",
    "    n2 = b.size\n",
    "    \n",
    "    numerator = (s1/n1 + s2/n2)**2\n",
    "    denominator = (s1/ n1)**2/(n1 - 1) + (s2/ n2)**2/(n2 - 1)\n",
    "    \n",
    "    return numerator/denominator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#connect to server\n",
    "conn = sqlite3.connect(r'C:\\Users\\krisdavis\\Documents\\GitHub\\Topic_11\\dsc-case-study-hypothesis-testing\\data\\northWind.sqlite')\n",
    "cur = conn.cursor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#preview data table names\n",
    "cur.execute(\"select * from sqlite_master\").fetchall()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 1: Is there a difference in quantity of products sold by discount rate? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Observations and Assumptions  \n",
    "Observations\n",
    "1. Chai has the highest quantity sold at 45 units/ 0.20 discount \n",
    "2. Charteuse verte sold 42 units at a 0.00 discoun\n",
    "3. The majority of the units represent multiple items \n",
    "\n",
    "Assumptions\n",
    "1. Currency is in US Dollars\n",
    "2. The discount represents a dollar amount not precentage\n",
    "3. A high ReorderLevel is desirable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Querring the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# orderdetail df\n",
    "cur.execute(\"\"\"SELECT SupplierId, OrderId, ProductId, CategoryId, CategoryName,  \n",
    "                      OrderDetail.UnitPrice, Quantity, Discount, ProductName, QuantityPerUnit, UnitsOnOrder, ReorderLevel\n",
    "               FROM OrderDetail  \n",
    "               JOIN Product \n",
    "               ON Product.Id = OrderDetail.ProductId \n",
    "               JOIN Category  \n",
    "               ON Product.CategoryId = Category.Id   \n",
    "               ORDER BY Category.CategoryName;\"\"\")\n",
    "product_df = pd.DataFrame(cur.fetchall()) \n",
    "product_df.columns = [x[0] for x in cur.description]\n",
    "product_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#cast needed columns as int/floats\n",
    "product_df['UnitPrice'] = product_df['UnitPrice'].astype(float)\n",
    "product_df['Quantity'] = product_df['Quantity'].astype(int)\n",
    "product_df['Discount'] = product_df['Discount'].astype(float) \n",
    "\n",
    "#create a % off column \n",
    "product_df['percentage_off'] = round((product_df.Discount / product_df.UnitPrice) * 100)\n",
    "product_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#all items Quantity v Discount\n",
    "sns.barplot(data=product_df, x=\"Quantity\", y=\"Discount\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#querry just beverages\n",
    "cur.execute(\"\"\"SELECT SupplierId, OrderId, ProductId, CategoryId, CategoryName, \n",
    "                    OrderDetail.UnitPrice, Quantity, Discount, QuantityPerUnit, ReorderLevel\n",
    "               FROM OrderDetail \n",
    "               JOIN Product  \n",
    "               ON Product.Id = OrderDetail.ProductId   \n",
    "               JOIN Category  \n",
    "               ON Product.CategoryId = Category.Id   \n",
    "               WHERE Category.CategoryName = 'Beverages' \n",
    "               ORDER BY ProductId;\"\"\")\n",
    "beverages_df = pd.DataFrame(cur.fetchall()) \n",
    "beverages_df.columns = [x[0] for x in cur.description]\n",
    "beverages_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#cast needed columns as int/floats\n",
    "beverages_df['UnitPrice'] = beverages_df['UnitPrice'].astype(float)\n",
    "beverages_df['Quantity'] = beverages_df['Quantity'].astype(int)\n",
    "beverages_df['Discount'] = beverages_df['Discount'].astype(float) \n",
    "\n",
    "#create a % off column \n",
    "beverages_df['percentage_off'] = round(((beverages_df.Discount / beverages_df.UnitPrice) * 100), 2)\n",
    "beverages_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#beverages Quantity v Discount\n",
    "sns.barplot(data=beverages_df, x=\"Quantity\", y=\"Discount\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#just look at 15$ outback lager\n",
    "outback_lager_df = beverages_df.loc[(beverages_df['ProductId'] == 70) & (beverages_df['UnitPrice'] == 15.0)] \n",
    "outback_lager_df "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Outback Lager Quantity v Discount\n",
    "sns.barplot(data=outback_lager_df, x=\"Quantity\", y=\"Discount\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "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>Id</th>\n",
       "      <th>CompanyName</th>\n",
       "      <th>ContactName</th>\n",
       "      <th>ContactTitle</th>\n",
       "      <th>Address</th>\n",
       "      <th>City</th>\n",
       "      <th>Region</th>\n",
       "      <th>PostalCode</th>\n",
       "      <th>Country</th>\n",
       "      <th>Phone</th>\n",
       "      <th>Fax</th>\n",
       "      <th>HomePage</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>7</td>\n",
       "      <td>Pavlova, Ltd.</td>\n",
       "      <td>Ian Devling</td>\n",
       "      <td>Marketing Manager</td>\n",
       "      <td>74 Rose St. Moonie Ponds</td>\n",
       "      <td>Melbourne</td>\n",
       "      <td>Victoria</td>\n",
       "      <td>3058</td>\n",
       "      <td>Australia</td>\n",
       "      <td>(03) 444-2343</td>\n",
       "      <td>(03) 444-6588</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Id    CompanyName  ContactName       ContactTitle  \\\n",
       "0   7  Pavlova, Ltd.  Ian Devling  Marketing Manager   \n",
       "\n",
       "                    Address       City    Region PostalCode    Country  \\\n",
       "0  74 Rose St. Moonie Ponds  Melbourne  Victoria       3058  Australia   \n",
       "\n",
       "           Phone            Fax HomePage  \n",
       "0  (03) 444-2343  (03) 444-6588     None  "
      ]
     },
     "execution_count": 323,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#find out more about supplier 7\n",
    "cur.execute(\"\"\"SELECT *\n",
    "               FROM Supplier \n",
    "               WHERE Id = 7\n",
    "              \"\"\")\n",
    "supplier_df = pd.DataFrame(cur.fetchall()) \n",
    "supplier_df.columns = [x[0] for x in cur.description]\n",
    "supplier_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Starting The Experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#caluclate the sample size needed for alpha values [0.1, 0.5, 0.01] & sell rate increase of [0.005, 0.01, 0.5, 0.2] \n",
    "sd = 0.0475\n",
    "e_sizes = [mu_delta/sd for mu_delta in [.005,.01,.02, .5]]\n",
    "fig, axes = plt.subplots(ncols=1, nrows=3, figsize=(8,15))\n",
    "for n, alpha in enumerate([.01, .05, .1]):\n",
    "    print(type(n), alpha)\n",
    "    ax = axes[n]\n",
    "    power_anaylsis.plot_power(dep_var=\"nobs\",\n",
    "                              nobs = np.array(range(5,500)),\n",
    "                              effect_size=e_sizes,\n",
    "                              alpha=alpha,\n",
    "                              ax=ax)\n",
    "    ax.set_title('Power of Test for alpha = {}'.format(alpha))\n",
    "    ax.set_xticks(list(range(0,500,25)))\n",
    "    ax.set_yticks(np.linspace(0,1,11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#drop all but the numerial values for outback lager 15$\n",
    "numerical_df = outback_lager_df.drop(['SupplierId', 'OrderId', 'ProductId', 'CategoryId', \n",
    "                                      'CategoryName', 'QuantityPerUnit', 'ReorderLevel'], axis=1) \n",
    "numerical_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What affect does discount rate have on quantity of sales by Pavlov, Ltd of Outback Lager at unit price 15?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Subset into percentage groups .33, .67, 1.33, 1.67\n",
    "percent0 = numerical_df.loc[outback_lager_df['percentage_off']==0.00] \n",
    "percent33 = numerical_df.loc[outback_lager_df['percentage_off']==0.33] \n",
    "percent133 = numerical_df.loc[outback_lager_df['percentage_off']==1.33]\n",
    "percent167 = numerical_df.loc[outback_lager_df['percentage_off']==1.33]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot the distribution of each \n",
    "sns.distplot(percent0)\n",
    "sns.distplot(percent33)\n",
    "sns.distplot(percent133)\n",
    "sns.distplot(percent167) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ANOVA Testing \n",
    "formula = 'Quantity ~ C(percentage_off)'\n",
    "lm = ols(formula, numerical_df).fit()\n",
    "table = sm.stats.anova_lm(lm, typ=2)\n",
    "print(table)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding the mean sales at each discount rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Sales(Population Mean): 19.857\n",
      "0.00% Off Average Sales (0Cent Discount Mean): 18.188\n",
      "0.33% Off Average Sales (5Cent Discount Mean): 21.0\n",
      "1.33% Off Average Sales (20Cent Discount Mean): 27.333\n",
      "1.67% Off Average Sales (25Cent Discount Mean: 27.333\n"
     ]
    }
   ],
   "source": [
    "#population mean\n",
    "pop_mean = round(numerical_df['Quantity'].sum()/len(numerical_df['Quantity']), 3)\n",
    "\n",
    "#mean quantity at each percentage off   \n",
    "mu_0 = round(percent0['Quantity'].sum()/len(percent0['Quantity']), 3)\n",
    "mu_33 = round(percent33['Quantity'].sum()/len(percent33['Quantity']), 3)\n",
    "mu_133 = round(percent133['Quantity'].sum()/len(percent133['Quantity']), 3)\n",
    "mu_167 = round(percent167['Quantity'].sum()/len(percent167['Quantity']), 3)\n",
    "\n",
    "print(f\"Average Sales(Population Mean): {pop_mean}\") \n",
    "print(f\"0.00% Off Average Sales (0Cent Discount Mean): {mu_0}\") \n",
    "print(f\"0.33% Off Average Sales (5Cent Discount Mean): {mu_33}\") \n",
    "print(f\"1.33% Off Average Sales (20Cent Discount Mean): {mu_133}\")\n",
    "print(f\"1.67% Off Average Sales (25Cent Discount Mean: {mu_167}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#distribution of sales by percentage off \n",
    "ax = sns.barplot(x=\"percentage_off\", y=\"Quantity\", data=numerical_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### No Discount \n",
    "\n",
    "    H0: The is no change in the quantity of sales when no discount is applied. \n",
    "\n",
    "    HA:The quantity of sales decreases by at least 1% when no discount rate is applied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sample contains 16 observations, having a mean of 18.188 and a standard deviation (sigma) =  15.371917035078393 , with 15 degrees of freedom. The difference between sample and population means is: -1.6690000000000005\n"
     ]
    }
   ],
   "source": [
    "#ttest 0.00  - No Discount Applied  \n",
    "\n",
    "# Population mean (μ)\n",
    "mu = pop_mean\n",
    "\n",
    "# Sample mean (x̄) using NumPy mean()\n",
    "x_bar = mu_0\n",
    "\n",
    "# Sample Stadrad Deviation (sigma) using Numpy\n",
    "sigma = np.std(percent0['Quantity'],ddof=1)\n",
    "\n",
    "# Sample size (n)\n",
    "n = len(percent0['Quantity'])\n",
    "\n",
    "# Degrees of Freedom\n",
    "df = n-1\n",
    "\n",
    "# Difference in sample mean \n",
    "diff = x_bar - mu\n",
    "\n",
    "\n",
    "# Print the findings\n",
    "print ('The sample contains', n, 'observations, having a mean of', x_bar, \"and a standard deviation (sigma) = \", sigma, \n",
    "       \", with\", df, 'degrees of freedom. The difference between sample and population means is:', diff) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9407452034519197\n"
     ]
    }
   ],
   "source": [
    "#pvalue of .00 percent off \n",
    "pop = [14, 6, 7, 15, 20, 15, 40, 50, 30, 8, 28, 40, 35, 5, 6, 9, 12, 30, 30, 4, 50, 30, 4, 50, 30, 3, 20, 30, 4, 3, 12]\n",
    "zero= [6, 7, 20, 50, 40, 35, 5, 6, 9, 12, 30, 4, 30, 30, 4, 3]\n",
    "\n",
    "num = np.mean(pop) - np.mean(zero)\n",
    "s = np.var(pop+zero)\n",
    "n = len(pop+zero)\n",
    "denom = s/np.sqrt(n)\n",
    "t = num / denom\n",
    "pval = stats.t.sf(np.abs(t), n-1)*2\n",
    "print(pval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P-value: 0.2991\n"
     ]
    }
   ],
   "source": [
    "iterations = 10**4\n",
    "diff_mu_a_b = np.mean(pop) - np.mean(zero)\n",
    "num = 0 #Initialize numerator\n",
    "for n in range(iterations):\n",
    "    ai, bi = bootstrap(pop, zero)\n",
    "    diff_mu_ai_bi = np.mean(ai) - np.mean(bi)\n",
    "    if diff_mu_ai_bi >= diff_mu_a_b:\n",
    "        num +=1\n",
    "p_val = num / iterations\n",
    "print('P-value: {}'.format(p_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Null hypothesis is True with t-value = -0.0 , critical t-value = 1.7530503556925547 and p-value = 0.9998979039\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "popmean = 18.188\n",
    "alpha = 0.05 \n",
    "sample = np.array([6, 7, 20, 50, 40, 35, 5, 6, 9, 12, 30, 4, 30, 30, 4, 3])\n",
    "one_sample_ttest(sample, popmean, alpha)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Analysis \n",
    "With an applied bootstrap our pval drops from 0.94 to 0.29 however we still fail to reject the null hypothesis. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### .33% Discount  \n",
    "\n",
    "\n",
    "    H0: The is no change in the quantity of sales at discount rate .33. \n",
    "\n",
    "    HA:The quantity of sales increases by at least 1% when sold at a .33% discount rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sample contains 3 observations, having a mean of 21.0 and a standard deviation (sigma) =  16.822603841260722 , with 2 degrees of freedom. The difference between sample and population means is: 2.812000000000001\n"
     ]
    }
   ],
   "source": [
    "#ttest 33\n",
    "# Population mean (μ)\n",
    "mu = 18.188\n",
    "\n",
    "# Sample mean (x̄) using NumPy mean()\n",
    "x_bar = mu_33\n",
    "\n",
    "# Sample Stadrad Deviation (sigma) using Numpy\n",
    "sigma = np.std(percent33['Quantity'],ddof=1)\n",
    "\n",
    "# Sample size (n)\n",
    "n = len(percent33['Quantity'])\n",
    "\n",
    "# Degrees of Freedom\n",
    "df = n-1\n",
    "\n",
    "# Difference in sample mean \n",
    "diff = x_bar - mu\n",
    "\n",
    "\n",
    "# Print the findings\n",
    "print ('The sample contains', n, 'observations, having a mean of', x_bar, \"and a standard deviation (sigma) = \", sigma, \n",
    "       \", with\", df, 'degrees of freedom. The difference between sample and population means is:', diff) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pvalue of .33 percent off\n",
    "pop = [14, 6, 7, 15, 20, 15, 40, 50, 30, 8, 28, 40, 35, 5, 6, 9, 12, 30, 30, 4, 50, 30, 4, 50, 30, 3, 20, 30, 4, 3, 12]\n",
    "b_33= [15, 40, 8]\n",
    "\n",
    "num = np.mean(pop) - np.mean(b_33)\n",
    "s = np.var(pop+b_33)\n",
    "n = len(pop+b_33)\n",
    "denom = s/np.sqrt(n)\n",
    "t = num / denom\n",
    "pval = stats.t.sf(np.abs(t), n-1)*2\n",
    "print(pval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 347,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P-value: 0.6274\n"
     ]
    }
   ],
   "source": [
    "iterations = 10**4\n",
    "diff_mu_a_b = np.mean(pop) - np.mean(b_33)\n",
    "num = 0 #Initialize numerator\n",
    "for n in range(iterations):\n",
    "    ai, bi = bootstrap(pop, b_33)\n",
    "    diff_mu_ai_bi = np.mean(ai) - np.mean(bi)\n",
    "    if diff_mu_ai_bi >= diff_mu_a_b:\n",
    "        num +=1\n",
    "p_val = num / iterations\n",
    "print('P-value: {}'.format(p_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Null hypothesis is True with t-value = 0.29 , critical t-value = 2.919985580355516 and p-value = 0.7994363304\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "popmean = 18.188\n",
    "alpha = 0.05 \n",
    "sample = np.array([15, 40, 8])\n",
    "one_sample_ttest(sample, popmean, alpha)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Analysis \n",
    "With an applied bootstrap our pval drops from 0.99 to 0.52 however we still fail to reject the null hypothesis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.33% Discount\n",
    "\n",
    "    H0: The is no change in the quantity of sales at discount rate 1.33. \n",
    "\n",
    "    HA:The quantity of sales increases by at least 1% when sold at a 1.33% discount rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sample contains 3 observations, having a mean of 27.333 and a standard deviation (sigma) =  20.033305601755625 , with 2 degrees of freedom. The difference between sample and population means is: 7.475999999999999\n"
     ]
    }
   ],
   "source": [
    "#ttest 133\n",
    "# Population mean (μ)\n",
    "mu = pop_mean\n",
    "\n",
    "# Sample mean (x̄) using NumPy mean()\n",
    "x_bar133 = mu_133\n",
    "\n",
    "# Sample Stadrad Deviation (sigma) using Numpy\n",
    "sigma = np.std(percent133['Quantity'],ddof=1)\n",
    "\n",
    "# Sample size (n)\n",
    "n = len(percent133['Quantity'])\n",
    "\n",
    "# Degrees of Freedom\n",
    "df = n-1\n",
    "\n",
    "# Difference in sample mean \n",
    "diff = x_bar133 - mu\n",
    "\n",
    "\n",
    "# Print the findings\n",
    "print ('The sample contains', n, 'observations, having a mean of', x_bar, \"and a standard deviation (sigma) = \", sigma, \n",
    "       \", with\", df, 'degrees of freedom. The difference between sample and population means is:', diff) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8679331935113082\n"
     ]
    }
   ],
   "source": [
    "#pvalue of 1.33 percent off\n",
    "pop = [14, 6, 7, 15, 20, 15, 40, 50, 30, 8, 28, 40, 35, 5, 6, 9, 12, 30, 30, 4, 50, 30, 4, 50, 30, 3, 20, 30, 4, 3, 12]\n",
    "b_133= [50, 20, 12]\n",
    "\n",
    "num = np.mean(pop) - np.mean(b_133)\n",
    "s = np.var(pop+b_133)\n",
    "n = len(pop+b_133)\n",
    "denom = s/np.sqrt(n)\n",
    "t = num / denom\n",
    "pval = stats.t.sf(np.abs(t), n-1)*2\n",
    "print(pval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P-value: 0.7686\n"
     ]
    }
   ],
   "source": [
    "iterations = 10**4\n",
    "diff_mu_a_b = np.mean(pop) - np.mean(b_133)\n",
    "num = 0 #Initialize numerator\n",
    "for n in range(iterations):\n",
    "    ai, bi = bootstrap(pop, b_133)\n",
    "    diff_mu_ai_bi = np.mean(ai) - np.mean(bi)\n",
    "    if diff_mu_ai_bi >= diff_mu_a_b:\n",
    "        num +=1\n",
    "p_val = num / iterations\n",
    "print('P-value: {}'.format(p_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Null hypothesis is True with t-value = 0.79 , critical t-value = 2.919985580355516 and p-value = 0.5119921439\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "popmean = 18.188\n",
    "alpha = 0.05 \n",
    "sample = np.array([50, 20, 12])\n",
    "one_sample_ttest(sample, popmean, alpha)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analysis: \n",
    "With an applied bootstrap our pval drops from 0.87 to 0.77 however we still fail to reject the null hypothesis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.67% Discount  \n",
    "\n",
    "\n",
    "    H0: The is no change in the quantity of sales at discount rate 1.67. \n",
    "\n",
    "    HA:The quantity of sales increases by at least 1% when sold at a 1.67% discount rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sample contains 3 observations, having a mean of 27.333 and a standard deviation (sigma) =  20.033305601755625 , with 2 degrees of freedom. The difference between sample and population means is: 7.475999999999999\n"
     ]
    }
   ],
   "source": [
    "#ttest 167\n",
    "# Population mean (μ)\n",
    "mu = pop_mean\n",
    "\n",
    "# Sample mean (x̄) using NumPy mean()\n",
    "x_bar = mu_167\n",
    "\n",
    "# Sample Stadrad Deviation (sigma) using Numpy\n",
    "sigma = np.std(percent167['Quantity'],ddof=1)\n",
    "\n",
    "# Sample size (n)\n",
    "n = len(percent167['Quantity'])\n",
    "\n",
    "# Degrees of Freedom\n",
    "df = n-1\n",
    "\n",
    "# Difference in sample mean \n",
    "diff = x_bar - mu\n",
    "\n",
    "\n",
    "# Print the findings\n",
    "print ('The sample contains', n, 'observations, having a mean of', x_bar, \"and a standard deviation (sigma) = \", sigma, \n",
    "       \", with\", df, 'degrees of freedom. The difference between sample and population means is:', diff) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8679331935113082\n"
     ]
    }
   ],
   "source": [
    "#pvalue of 1.67 percent off\n",
    "pop = [14, 6, 7, 15, 20, 15, 40, 50, 30, 8, 28, 40, 35, 5, 6, 9, 12, 30, 30, 4, 50, 30, 4, 50, 30, 3, 20, 30, 4, 3, 12]\n",
    "b_167= [50, 20, 12]\n",
    "\n",
    "num = np.mean(pop) - np.mean(b_167)\n",
    "s = np.var(pop+b_167)\n",
    "n = len(pop+b_167)\n",
    "denom = s/np.sqrt(n)\n",
    "t = num / denom\n",
    "pval = stats.t.sf(np.abs(t), n-1)*2\n",
    "print(pval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P-value: 0.7652\n"
     ]
    }
   ],
   "source": [
    "iterations = 10**4\n",
    "diff_mu_a_b = np.mean(pop) - np.mean(b_167)\n",
    "num = 0 #Initialize numerator\n",
    "for n in range(iterations):\n",
    "    ai, bi = bootstrap(pop, b_167)\n",
    "    diff_mu_ai_bi = np.mean(ai) - np.mean(bi)\n",
    "    if diff_mu_ai_bi >= diff_mu_a_b:\n",
    "        num +=1\n",
    "p_val = num / iterations\n",
    "print('P-value: {}'.format(p_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Null hypothesis is True with t-value = 0.79 , critical t-value = 2.919985580355516 and p-value = 0.5119921439\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "popmean = 18.188\n",
    "alpha = 0.05 \n",
    "sample = np.array([50, 20, 12])\n",
    "one_sample_ttest(sample, popmean, alpha)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analysis:  \n",
    "With an applied bootstrap our pval drops from 0.86 to 0.77 however we still fail to reject the null hypothesis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building a DF to directly compare hypothetical randomly generated quanities for each discount rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generate random numbers in data to expand sample size \n",
    "import random\n",
    "\n",
    "randomlist = random.sample(range(2, 51), 28)\n",
    "print(randomlist) \n",
    "\n",
    "pop = np.array([14, 6, 7, 15, 20, 15, 40, 50, 30, 8, 28, 40, 35, 5, 6, 9, 12, 30, 30, 4, 50, 30, 4, 50, 30, 3, 20, 30, 4, 3, 12])\n",
    "zero_rand= np.array([6, 7, 20, 50, 40, 35, 5, 6, 9, 12, 30, 4, 30, 30, 4, 3, 30, 43, 2, 35, 49, 26, 44, 47, 21, 23, 45, 9, 46, 6, 27])\n",
    "rand_33= np.array([15, 40, 8, 22, 35, 33, 15, 46, 31, 23, 5, 38, 32, 13, 36, 44, 27, 2, 18, 8, 39, 42, 24, 17, 47, 3, 49, 45, 7, 30, 6]) \n",
    "rand_133 = np.array([50, 20, 12, 18, 35, 31, 43, 28, 9, 15, 27, 11, 50, 5, 36, 29, 12, 14, 20, 30, 19, 23, 48, 7, 42, 46, 40, 26, 22, 17, 34])\n",
    "rand_167 = np.array([50, 20, 12, 15, 16, 17, 12, 24, 22, 41, 39, 26, 20, 4, 43, 3, 32, 49, 5, 45, 25, 13, 7, 28, 34, 14, 40, 44, 37, 36, 42])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#DF of quantity sold by percent discount \n",
    "df = pd.DataFrame(list(zip(pop, zero_rand, rand_33, rand_133, rand_167)), \n",
    "                  columns =['popquantities', 'quantities0', 'quantities33', 'quantites133', 'quantites167'], dtype=int) \n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [],
   "source": [
    "#mean of hypothetical lists\n",
    "popmean = 20.645161\n",
    "zeromean = 24.000000\n",
    "mean33 = 25.806452\n",
    "mean133 = 26.419355\n",
    "mean167 = 26.290323"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ANOVA \n",
    "formula = 'popquantities ~ C(quantities33) + C(quantites133) + C(quantites167) + quantities0' \n",
    "lm = ols(formula, df).fit()\n",
    "table = sm.stats.anova_lm(lm, typ=2)\n",
    "print(table)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pop to Zero "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8318864275257802"
      ]
     },
     "execution_count": 304,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Welch's Ttest pop/ 0 discount\n",
    "a = pop\n",
    "b = zero_rand\n",
    "welch_t(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "59.65459771058358"
      ]
     },
     "execution_count": 311,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#degree of freedom\n",
    "a = pop\n",
    "b = zero_rand\n",
    "welch_df(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.20439540047279947\n"
     ]
    }
   ],
   "source": [
    "#pval\n",
    "p = 1 - stats.t.cdf(0.8318864275257802, 59.65459771058358)\n",
    "print(p) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Visualize density\n",
    "sns.kdeplot(data=zero_rand)\n",
    "sns.despine()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pop To 0.33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.3470100620554153"
      ]
     },
     "execution_count": 306,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Welch's Ttest pop/ .33 discount\n",
    "a = pop\n",
    "b = rand_33\n",
    "welch_t(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "59.96700889639937"
      ]
     },
     "execution_count": 312,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#degree of freedom\n",
    "a = pop\n",
    "b = rand_33\n",
    "welch_df(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.09152272024147734\n"
     ]
    }
   ],
   "source": [
    "#pval\n",
    "p = 1 - stats.t.cdf(1.3470100620554153, 59.96700889639937)\n",
    "print(p) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#visulaize density\n",
    "sns.kdeplot(data=rand_33)\n",
    "sns.despine()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pop To 1.33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5862836209834563"
      ]
     },
     "execution_count": 307,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Welche's Ttest pop/ 1.33 discount\n",
    "a = pop\n",
    "b = rand_133\n",
    "welch_t(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "58.941248473924816"
      ]
     },
     "execution_count": 313,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#degree of freedom\n",
    "a = pop\n",
    "b = rand_133\n",
    "welch_df(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.05901293368378724\n"
     ]
    }
   ],
   "source": [
    "#pval\n",
    "p = 1 - stats.t.cdf(1.5862836209834563, 58.941248473924816)\n",
    "print(p) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#visulaize density\n",
    "sns.kdeplot(data=rand_133)\n",
    "sns.despine()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pop To 1.67"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5012861420682635"
      ]
     },
     "execution_count": 309,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Welch's Ttest pop/ 1.67 discount\n",
    "a = pop\n",
    "b = rand_167\n",
    "welch_t(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "59.76491168123537"
      ]
     },
     "execution_count": 314,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#degree of freedom\n",
    "a = pop\n",
    "b = rand_167\n",
    "welch_df(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0692733674443099\n"
     ]
    }
   ],
   "source": [
    "#pval\n",
    "p = 1 - stats.t.cdf(1.5012861420682635, 59.76491168123537)\n",
    "print(p) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#visualizing density\n",
    "sns.kdeplot(data=rand_167)\n",
    "sns.despine()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\krisdavis\\Anaconda4\\lib\\site-packages\\seaborn\\axisgrid.py:1840: UserWarning: JointGrid annotation is deprecated and will be removed in a future release.\n",
      "  warnings.warn(UserWarning(msg))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(style=\"darkgrid\", color_codes=True)\n",
    "j = sns.jointplot('Discount', 'Quantity', data = numerical_df, kind='reg', height=8).annotate(stats.pearsonr)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I failed to reject the null hypothesis at 0.00, 0.33, 1.33, and 1.67 % discount rate. This leads me to the recommendation that Pavlov, Ltd should stop discounting their Outback Lager as it does not lead to higher sales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EffectSize/PowerAnalysis/Tukey Testing (if needed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 2: Is there a difference in number of orders and territory? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# obtain necessary data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## {Put test name here}\n",
    "H0: \n",
    "\n",
    "HA:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perform test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 3: {You decide}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# obtain necessary data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## {Put test name here}\n",
    "H0: \n",
    "\n",
    "HA:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# perform test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EffectSize/PowerAnalysis/Tukey Testing (if needed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}