From 28dceb5cf66eff06067655827a95f0c82c992e2d Mon Sep 17 00:00:00 2001
From: Rickard Ramhoej <rickard.ramhoj@gmail.com>
Date: Fri, 2 Jul 2021 18:10:57 +0100
Subject: [PATCH] Adding my solutions to the descriptive stats lab

---
 your-code/main.ipynb | 889 +++++++++++++++++++++++++++++++++++++++----
 1 file changed, 825 insertions(+), 64 deletions(-)

diff --git a/your-code/main.ipynb b/your-code/main.ipynb
index a0a5b66..62a8d34 100644
--- a/your-code/main.ipynb
+++ b/your-code/main.ipynb
@@ -11,11 +11,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Libraries"
+    "# Libraries\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy import stats\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import sklearn\n",
+    "from sklearn.preprocessing import MinMaxScaler\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "import random"
    ]
   },
   {
@@ -29,11 +38,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# define function\n",
+    "def ten_dice_rolls():\n",
+    "    return pd.DataFrame(random.choices(range(1,7), k=10))\n",
+    "\n",
+    "# test function\n",
+    "dice_rolls = ten_dice_rolls()"
    ]
   },
   {
@@ -45,11 +61,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 91,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# define bars\n",
+    "bars = list(dice_rolls[0].value_counts().index)\n",
+    "\n",
+    "# define heights of bars\n",
+    "heights = list(dice_rolls[0].value_counts())\n",
+    "\n",
+    "# define plot\n",
+    "plt.bar(bars, heights)\n",
+    "\n",
+    "# define plot\n",
+    "#plt.plot(dice_rolls[0].sort_values())\n",
+    "\n",
+    "# display plot\n",
+    "plt.show()"
    ]
   },
   {
@@ -61,11 +105,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([3., 0., 3., 3., 0., 1.]),\n",
+       " array([1.        , 1.83333333, 2.66666667, 3.5       , 4.33333333,\n",
+       "        5.16666667, 6.        ]),\n",
+       " <BarContainer object of 6 artists>)"
+      ]
+     },
+     "execution_count": 5,
+     "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": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# create a histogram\n",
+    "plt.hist(dice_rolls[0], bins=6)\n",
+    "\n"
    ]
   },
   {
@@ -76,6 +150,8 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "With the bar chart you get discreet bars, while with the histogram they go into each other and you decide the number of bins\n",
     "\"\"\""
    ]
   },
@@ -91,11 +167,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3.0"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# define fucntion\n",
+    "def _mean(df_series):\n",
+    "    return df_series.sum()/len(df_series)\n",
+    "\n",
+    "# test function\n",
+    "_mean(dice_rolls[0])"
    ]
   },
   {
@@ -107,11 +201,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.5"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# calculate frequency distribution using value_counts()\n",
+    "freq_dist = dice_rolls[0].value_counts()\n",
+    "\n",
+    "# calculate mean\n",
+    "sum(freq_dist) / len(freq_dist.index)\n"
    ]
   },
   {
@@ -124,11 +235,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 34,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3.0"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# define function\n",
+    "def _median(df_series):\n",
+    "    if len(df_series) % 2 == 0:\n",
+    "        first_middle = df_series.sort_values().reset_index(drop=True)[len(df_series)/2]\n",
+    "        second_middle = df_series.sort_values().reset_index(drop=True)[(len(df_series)/2)-1]\n",
+    "        median = (first_middle + second_middle) / 2\n",
+    "    else:\n",
+    "        median = df_series.sort_values().reset_index(drop=True)[(len(df_series)+1)/2]\n",
+    "    return median\n",
+    "\n",
+    "# test function\n",
+    "_median(dice_rolls[0])\n"
    ]
   },
   {
@@ -140,11 +275,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 47,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Lower Quartile: 3\n",
+      "Upper Quartile: 4\n"
+     ]
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# define function\n",
+    "def quartile(data):\n",
+    "            data = data.sort_values().reset_index(drop=True)               \n",
+    "            half_list = int(len(data)//2)\n",
+    "            upperdata = data[half_list:]\n",
+    "            lowerdata = data[:half_list]\n",
+    "            upper_quartile = _median(upperdata)\n",
+    "            lower_quartile = _median(lowerdata)\n",
+    "            print(\"Lower Quartile: \"+str(lower_quartile))\n",
+    "            print(\"Upper Quartile: \"+str(upper_quartile))\n",
+    "\n",
+    "# test function\n",
+    "quartile(dice_rolls[0]) \n"
    ]
   },
   {
@@ -158,11 +316,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 57,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# load file\n",
+    "roll_the_dice_hundred = pd.read_csv(\"/Users/rickardramhoj/ironhack_assignments/lab-understanding-descriptive-stats/data/roll_the_dice_hundred.csv\", index_col=0)\n",
+    "\n",
+    "# check out df\n",
+    "plt.hist(roll_the_dice_hundred[\"value\"], bins=6)\n",
+    "\n",
+    "plt.show()\n"
    ]
   },
   {
@@ -173,6 +352,8 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "There are some differences in the number of instances of each number. The number 6 has the highest frequency. \n",
     "\"\"\""
    ]
   },
@@ -185,11 +366,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 58,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3.74"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# apply _mean function\n",
+    "_mean(roll_the_dice_hundred[\"value\"])"
    ]
   },
   {
@@ -201,11 +396,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 59,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6    23\n",
+       "4    22\n",
+       "2    17\n",
+       "3    14\n",
+       "1    12\n",
+       "5    12\n",
+       "Name: value, dtype: int64"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# frequency distribution using value_counts()\n",
+    "roll_the_dice_hundred[\"value\"].value_counts()"
    ]
   },
   {
@@ -217,11 +432,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 61,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAK1UlEQVR4nO3dX4jl91nH8c/TJKKmLU3JNCxNcVVCMQgmYYlKoERjS2qLiReCAUuQwnqRSouCxN5U7+KF1RspxCQ2YptSmoYWU2pDrKQFrc7GaBLT0lKiXRu7E4I08aYkfbzYE1i2u53ZmXPm7LPzesFwzvnNOef3/C72zW+/c/5UdweAeV6z7gEA2B0BBxhKwAGGEnCAoQQcYKiL93Nnl19+eR8+fHg/dwkw3rFjx57v7o3Tt+9rwA8fPpzNzc393CXAeFX1n2fabgkFYCgBBxhKwAGGEnCAoQQcYCgBBxhKwAGGEnCAoQQcYKh9fScmwLk4fOfD6x5haZ69611Lf05n4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwzljTwQbxhhJmfgAEMJOMBQAg4wlIADDCXgAEMJOMBQAg4wlIADDCXgAEMJOMBQAg4wlIADDCXgAEMJOMBQ2wa8qt5SVV+sqmeq6umqev9i+xur6pGq+vri8rLVjwvAq3ZyBv5ykt/v7p9J8gtJ7qiqq5PcmeTR7r4qyaOL2wDsk20D3t3Pdffji+svJnkmyZuT3JLk/sXd7k9y64pmBOAMzmkNvKoOJ7k2yVeSXNHdzyUnI5/kTWd5zNGq2qyqza2trT2OC8CrdhzwqnptkgeTfKC7v7vTx3X33d19pLuPbGxs7GZGAM5gRwGvqktyMt4f6+5PLzZ/p6oOLX5/KMmJ1YwIwJns5FUoleTeJM9094dP+dVnk9y+uH57ks8sfzwAzmYn30p/Q5L3JHmyqp5YbPtgkruSfLKq3pvkv5L8xkomBOCMtg14d385SZ3l1zctdxwAdso7MQGGEnCAoQQcYCgBBxhKwAGGEnCAoQQcYCgBBxhKwAGGEnCAoQQcYCgBBxhKwAGGEnCAoQQcYCgBBxhKwAGGEnCAoQQcYCgBBxhKwAGG2vZb6Vm+w3c+vO4RlubZu9617hHgwHIGDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMtW3Aq+q+qjpRVU+dsu2Pquq/q+qJxc+vrnZMAE63kzPwjya5+Qzb/6y7r1n8fG65YwGwnW0D3t2PJXlhH2YB4BzsZQ38fVX174sllsvOdqeqOlpVm1W1ubW1tYfdAXCq3Qb8I0l+Osk1SZ5L8qdnu2N3393dR7r7yMbGxi53B8DpdhXw7v5Od7/S3d9P8pdJrl/uWABsZ1cBr6pDp9z89SRPne2+AKzGtt9KX1UPJLkxyeVVdTzJh5LcWFXXJOkkzyb5ndWNCMCZbBvw7r7tDJvvXcEsAJwD78QEGErAAYYScIChtl0Dhx/m8J0Pr3sEOLCcgQMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMNeYbeXzzC+yMfysHhzNwgKEEHGAoAQcYSsABhhJwgKEEHGAoAQcYSsABhhJwgKEEHGAoAQcYSsABhhJwgKEEHGCobQNeVfdV1YmqeuqUbW+sqkeq6uuLy8tWOyYAp9vJGfhHk9x82rY7kzza3VcleXRxG4B9tG3Au/uxJC+ctvmWJPcvrt+f5NbljgXAdna7Bn5Fdz+XJIvLN53tjlV1tKo2q2pza2trl7sD4HQr/yNmd9/d3Ue6+8jGxsaqdwdwYOw24N+pqkNJsrg8sbyRANiJ3Qb8s0luX1y/PclnljMOADu1k5cRPpDkH5O8taqOV9V7k9yV5O1V9fUkb1/cBmAfXbzdHbr7trP86qYlzwLAOfBOTIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYa6eC8Prqpnk7yY5JUkL3f3kWUMBcD29hTwhV/q7ueX8DwAnANLKABD7TXgneQLVXWsqo6e6Q5VdbSqNqtqc2tra4+7A+BVew34Dd19XZJ3Jrmjqt52+h26++7uPtLdRzY2Nva4OwBetaeAd/e3F5cnkjyU5PplDAXA9nYd8Kq6tKpe9+r1JO9I8tSyBgPgh9vLq1CuSPJQVb36PB/v7s8vZSoAtrXrgHf3N5P83BJnAeAceBkhwFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQ+0p4FV1c1V9raq+UVV3LmsoALa364BX1UVJ/iLJO5NcneS2qrp6WYMB8MPt5Qz8+iTf6O5vdvf3knwiyS3LGQuA7Vy8h8e+Ocm3Trl9PMnPn36nqjqa5Oji5ktV9bVd7u/yJM/v8rFTOeaDwTEfAPUnezrmnzjTxr0EvM6wrX9gQ/fdSe7ew35O7qxqs7uP7PV5JnHMB4NjPhhWccx7WUI5nuQtp9y+Msm39zYOADu1l4D/S5Krquonq+pHkvxmks8uZywAtrPrJZTufrmq3pfk75JclOS+7n56aZP9oD0vwwzkmA8Gx3wwLP2Yq/sHlq0BGMA7MQGGEnCAoc77gFfVfVV1oqqeWvcs+6Wq3lJVX6yqZ6rq6ap6/7pnWqWq+tGq+ueq+rfF8f7xumfaL1V1UVX9a1X97bpn2Q9V9WxVPVlVT1TV5rrn2Q9V9Yaq+lRVfXXxb/oXl/bc5/saeFW9LclLSf66u3923fPsh6o6lORQdz9eVa9LcizJrd39H2sebSWqqpJc2t0vVdUlSb6c5P3d/U9rHm3lqur3khxJ8vrufve651m1qno2yZHuPjBv4qmq+5N8qbvvWbxi78e7+3+X8dzn/Rl4dz+W5IV1z7Gfuvu57n58cf3FJM/k5DtfL0h90kuLm5csfs7vM4slqKork7wryT3rnoXVqKrXJ3lbknuTpLu/t6x4JwMCftBV1eEk1yb5yppHWanFUsITSU4keaS7L+jjXfjzJH+Q5PtrnmM/dZIvVNWxxcdsXOh+KslWkr9aLJXdU1WXLuvJBfw8VlWvTfJgkg9093fXPc8qdfcr3X1NTr6j9/qquqCXy6rq3UlOdPexdc+yz27o7uty8lNM71gskV7ILk5yXZKPdPe1Sf4vydI+elvAz1OLteAHk3ysuz+97nn2y+K/l/+Q5Ob1TrJyNyT5tcWa8CeS/HJV/c16R1q97v724vJEkody8lNNL2THkxw/5X+Un8rJoC+FgJ+HFn/UuzfJM9394XXPs2pVtVFVb1hc/7Ekv5Lkq2sdasW6+w+7+8ruPpyTH0Px9939W2sea6Wq6tLFH+WzWEZ4R5IL+tVl3f0/Sb5VVW9dbLopydJejLCXTyPcF1X1QJIbk1xeVceTfKi7713vVCt3Q5L3JHlysS6cJB/s7s+tb6SVOpTk/sWXhLwmySe7+0C8rO6AuSLJQyfPT3Jxko939+fXO9K++N0kH1u8AuWbSX57WU983r+MEIAzs4QCMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABD/T9HG0ZYd5BkMQAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# create histogram\n",
+    "plt.hist(roll_the_dice_hundred[\"value\"], bins=6)\n",
+    "\n",
+    "# display plot\n",
+    "plt.show()"
    ]
   },
   {
@@ -232,6 +466,9 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "There are some differences in the number of instances of each number. The number 6 has the highest frequency. \n",
+    "\n",
     "\"\"\""
    ]
   },
@@ -244,11 +481,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 63,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# load file\n",
+    "roll_the_dice_hundred = pd.read_csv(\"/Users/rickardramhoj/ironhack_assignments/lab-understanding-descriptive-stats/data/roll_the_dice_thousand.csv\", index_col=0)\n",
+    "\n",
+    "# check out df\n",
+    "plt.hist(roll_the_dice_hundred[\"value\"], bins=6)\n",
+    "\n",
+    "plt.show()"
    ]
   },
   {
@@ -259,6 +517,8 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "With the increasing number of instances, the differences between the numbers get smaller. Since it should be the same probability for each number, the differences will disappear more or less if we have enough observations. \n",
     "\"\"\""
    ]
   },
@@ -274,11 +534,136 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 73,
    "metadata": {},
-   "outputs": [],
+   "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>observation</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>68.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>12.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>45.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>38.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>49.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>995</th>\n",
+       "      <td>27.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>996</th>\n",
+       "      <td>47.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>997</th>\n",
+       "      <td>53.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>998</th>\n",
+       "      <td>33.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>999</th>\n",
+       "      <td>31.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1000 rows × 1 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     observation\n",
+       "0           68.0\n",
+       "1           12.0\n",
+       "2           45.0\n",
+       "3           38.0\n",
+       "4           49.0\n",
+       "..           ...\n",
+       "995         27.0\n",
+       "996         47.0\n",
+       "997         53.0\n",
+       "998         33.0\n",
+       "999         31.0\n",
+       "\n",
+       "[1000 rows x 1 columns]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABTaUlEQVR4nO2dd5gdtbn/v+/Zde/G3WBMMZhuwBgDodqmmQCXNLiBaxII6SEkuYlJIOUmv+CbQihJCISEayCQECCB0IIxvXsN2BjbsLgbt3Wv6y1Hvz9m5hyNRpqRppxzZq3P8+wze6ZIGo3mnVevXr0ixhgsFovFkj8K1S6AxWKxWOJhBbjFYrHkFCvALRaLJadYAW6xWCw5xQpwi8ViySn1lcxswIABbOTIkZXM0mKxWHLP7Nmz1zPGBor7KyrAR44ciYaGhkpmabFYLLmHiJbJ9lsTisViseQUK8AtFoslp1gBbrFYLDnFCnCLxWLJKVaAWywWS06xAtxisVhyihXgFovFklOsALdkyjPz12LNluZqF8Ni6ZBYAW7JlCvvbsBFv3+l2sWwWDokVoBbMmeV1cAtlkzQEuBEdA0RvUdE84jofiLqSkT9iWgGETW6235ZF9ZisVgsZSIFOBENB/ANAGMZY4cDqANwMYCpAGYyxkYBmOn+tlgsFkuF0DWh1APoRkT1ALoDWAXgAgDT3ePTAVyYeuksucaut2qxZEukAGeMfQTgVwCWA1gNYAtj7GkAgxljq91zVgMYJLueiK4iogYiamhqakqv5Jaax8pviyVbdEwo/eBo2/sBGAagBxFdqpsBY+wOxthYxtjYgQMD4WwtFovFEhMdE8pEAEsYY02MsVYADwM4EcBaIhoKAO52XXbFtOQRq4BbLNmiI8CXAxhPRN2JiABMALAAwKMAprjnTAHwSDZFtOQVawO3WLIlckUextgbRPQggLcAtAF4G8AdAHoCeICIroAj5D+VZUEt+cOKb4slW7SWVGOM/QjAj4Tdu+Fo4xaLxWKpAnYmpiUzrAXFYskWK8AtmcGsEcViyRQrwC0WiyWnWAFuyQxrQrFYssUKcIvFYskpVoBbMsNq4BZLtlgBbrFYLDnFCnBLZlgvFIslW6wAt2SGNaFYLNliBbglM6z8tliyxQpwSyKaW9txz+vLUCxacW2xVBqtWCgWi4qbnmnEH15YhD7dOuH8o4b5jtlohBZLtlgN3JKIzTtbAADbm9sCx6z4tliyxQpwSyKIql0Ci2XPxQpwS0IcCS5zGbQWFIslW3TWxDyYiN7h/rYS0TeJqD8RzSCiRnfbrxIFttQWngYuFdY1LsDXbW3GjU+/bwdgLblFZ1X69xljYxhjYwAcC2AngH8AmApgJmNsFICZ7m/LHopcfte2YPz23+fglmc/xFvLN1W7KBZLLExNKBMALGKMLYOzUv10d/90ABemWC5LTqiWCbytvYimbbsTpbG7tQgAaLcauCWnmArwiwHc7/4/mDG2GgDc7aA0C2bJGRIbSpY28J8+Nh/H/b9nsLW5NXFaVnxb8oq2ACeizgDOB/B3kwyI6CoiaiCihqamJtPyWWqcMC+ULAXjU++tAQDs2B10X9QmzH5vseQAEw38HABvMcbWur/XEtFQAHC362QXMcbuYIyNZYyNHThwYLLSWmoWqQ08Q8noJU0JjDjelWG2+i07W3HV3Q3YtKMldj4WS1aYCPBLUDafAMCjAKa4/08B8EhahbLkB0+AVlqL9bJL4odOZQmuZPprS/H0/LX48ytL4mdksWSElgAnou4AJgF4mNs9DcAkImp0j01Lv3gO767cgqfmrckqeUsCqmVCKWvglo7Goqbt2LJTPrZRLDK8s2JzZQtUw2gJcMbYTsbYXoyxLdy+DYyxCYyxUe52Y1aFfKBhBb7/j3ezSt6SAjJzSbZaeXIJXiBvEpKllpjw6xdw3m9fkh778ytLcOHvXsGrH66vcKlqk9zMxLSBkWqTamnAqdjA7SBmzbJi4y7p/gWrtwEAVm6WH9/TyIUAt/E2kvPFexrwmxkfZJZ+pSfypJlyrU84qmXa2os4/VfP46l5qxOntWVXK8b+7BmtcyspEhqWbkzNZTVtciHAAdvNTcq/31uLm2c2pp4uVckIXnTV5iTCt1oDsB2Jrc1tWLJ+B6Y+nNzEOXvZRqzfHj45qxof2xtnfICmbbsxd8WW6JMrTC4EOMG+ZNVk1tKNWBXRZZU9nzQf2fbdbXhm/trS71J+CTIpmVBCzkm73W3Z1Yrn3pd63OaaNDTiUGXAwzOdVbBbXssWgHwI8FquwT2AT/3hNZz6y+eqWobvPTQXV97dgEVN2wGUx0Ty9l3/2n1v4XN3zcK6bc3VLkoqpDk2ZfKWW4ngkAsBDthBzGrT2i6v/zAtNs1HtnzDTgDlmZclBTyFPCrZthY37QAAtLQVK5ZnJUhDySpopFFNKVCLYyW5EeCW2qRsR5a4EabY4Avuu10KPOVuigmELxm4EeZV49uysxUjpz6OR975KJP00xRpJt+ALDrla7Y0Y+TUx/HcQr+JK4mnU9bkRoDX3rfPEkWaim3BleCC/E7ULkqvZUgiOnbyOFRK6V+20dH4//jS4kzST3NCVbUF5dyVmwEA97+5vKrlMCEXAjyNr+3S9Tvwj7dXJk/I4qNSwxNe97rkfSJs46A1ZpZzzaFUbxlbbNJoB3rPw3kg976+LNJjZU8gFwIcQGIV6JybX8I1f5uTTlksAbL2Qqlz327PhFLSxNOwgXfg/p344UubNOtO5xvg5fbW8s34+n1vp5a3DrX4Mc+FACdQ7GbS3NoOANjlbjsiu9vaq7YsmOyl293WDsZYbO24vcgCg3wFt6XG9f8uStIsxbKqwRczLcJmm6bbbihxmjoDofx9bMwoQqRY+qzMaGmQDwEes3v2cuN6jL7+KcxamlmYlprg4Ouewg/+Wd1YMZ5AbW5tx8HXPYVpTy6MndYX7m7AQdc96dtXilsiaN66wver970VSJOENMNIy1JUaY/YcrwX/00WiwwHX/cUfvKv95JlUPLLdrZJ2qL1FjYnFwIciGfrfGWRE/DmzSUdV4C3tTta5f1vrqhK/qKGt6vF6en8rWFFbM322YXBiS4FwYRSHsTUy+RJSTTLPUFeBLx3XNrc3395I9mAXSmsL7cvbls0fR5pm76iegC16MqcCwGepxftTy8vwexl8kVyX1u0Afe8vizV/Ha7ZoG6QvJaunVmIxau2Wp0TaUmWXleKO0l1dvZJLEA1HLXOC28ehNljyf80nx8SQWclgnFl1+i7LR5qbF2Ix/mQoAD6b1kWX9Ff/rYfHzitlelxy754+u4/p/zUs3PE+Cd65I9ytb2In494wNc9Ht52aMQa5WxdF+wupKm77eBJ3ueah/2rKlUlqpBzDSiOfLpiP/HwcQLxeKQCwGerpaQXlq1wO42x2TRuT7Zo/Re8NZ2M38z8dFkpZCXTSjOb0ERT0SaTaJYZFixcafyeLXsvGJPJa33wGs3RMnrUacTWYnXN08yQndFnr5E9CARLSSiBUR0AhH1J6IZRNTobvtlWdC0G1xHYXerI9E6JdTAk2pkcjfCFGdiFvyaZNkfPH6aWQjT215YhJN/8Rw+XLdNerziS88J9VXan9KzKdvAqSImFFneaVHOXZ5yLUoO3bf+ZgBPMcZGAzgKwAIAUwHMZIyNAjDT/Z0JadpZa/EhJMEzoXRJqIGXMK3qsGiyac7EDJhQSrnETjMLN8LXF28AAHy0OTxYVaU0cZW/fLEseZOlXyxr4Ek9EmtxrKvWTTaRbz0R9QZwCoA/AQBjrIUxthnABQCmu6dNB3BhNkV0CNMY7ntjOW54YoFeOrX9PIzxTCid6pI1/1JXOOb14vNhLF0fAZUJ5eq/vhM4t7m1HZfe+QbeXyPXgj3KQrTj2sC9exM18LDnvWLjTnz69tewZZfZAgZJn7hJOFkgfeEqy77W5YWO2rY/gCYAdxHR20R0JxH1ADCYMbYaANztINnFRHQVETUQUUNTU1OsQkbFA//+P97F7S/qxXroaLPuSoOYiW3gztZUMxRNLlnFswh4obi8tyroNTN72Sa8/OF6/PhRPR/nSr6klbaBe/cWMKEU1eW5ZWYj3lyyEf/WWEg8zUFMHVgqfS99fPVWg6JD562vB3AMgNsYY0cD2AEDcwlj7A7G2FjG2NiBAwfGK6UdxFTi2cA/WLu95IM9d+VmbHfDrupS1siS2cBL3iHwa0ibdrRgvkTY6lJXmnRj/gBVdVGKpBi7VOEsXLMVG6ocr8O7t8AgZshdl44omsKqzbuwZP0ON92yJp/03dJ5trp5bNrRggWr47c3j6JPftee8NAR4CsBrGSMveH+fhCOQF9LREMBwN1musxIem6EKSVUI/BeI999aC6aW9tx/m9fwRfvaTBKJ0wjC0M8X6Ww/MfvX8G5t8hXGtfBs4GbDEJ7ZVPVRdaLGp9900s45+b495wG5RmrognF2co+2FERBk+c9ixO/9XzzrnuPiJKLOCMrw654LxbX45d96zGhTZPpABnjK0BsIKIDnZ3TQAwH8CjAKa4+6YAeCSTEiLdbnmtPxBTeIH23qotaHEF+hzD9fvi1kt5IFAcXPSzdIPatU4H0Qaug1c1by/fLD1ensiTXZtYt02ugVeqHZa9duT7pXbf0iSf6PeOb3/JNXDD80OOfZTSqvW1rvDpGk6/DuAvRDQXwBgAPwcwDcAkImoEMMn9nR0pVWTSB7Jk/Q7sd+3j+HDd9tK+Vxetx0E/eBJbdqoHfaa/ujRZxgr4+ykQxY7PXIx5XVADT++F5im5EWq4Ooj3oCqHjmKQ9MMWJ0+R2cs24sDvPyE1x7QXGY796Qw8NFseKlllAw/tyRi0BT6Z5C668U0o97y+DCdNexYA0KT4aEYh+16l+YHKAi0Bzhh7x7VjH8kYu5AxtokxtoExNoExNsrdZhZwJNWJPAmv/9ecVWAMvhVObp35IVrai5i3Sq31/khzQM0U/n4KxO0wrLOyRpbUBq4qXZw0y9fHMaFEpYmMTShpcdvzi9FWZGiQhGjY1dqODTtacP0j8hm+3gdI/PCld8/pDSrqlMk3iMldcP0/55W07jeWbEhYErMyVZNczMQEUpx4kMETKXU5U0/ZjA/Wbo8syzPz10o1lLhuhOJAYKl6mWJyD2P415xVWoOsd72yFJvckKF1Ci+UMLy64EMJF4PyuypGNZNm2Fb0JmsFn07U81JFbQzrqZXt2tFl472XEptQUjifMZaqybXWJ/7lQoCnMcLtkYWWUNpXBQkufpC27nIEo0qTvvLuBlx65xuB/XHvIWBCiajh91ZtxdfvfxtTH5obmfb/PDYfX7p3NgA+podOocr/Lhds79K1O3UaV8r+fybt0BuoTjLbVukHLrkvVjoWnS7zCfDshV2U22KRpfuoihH5VZt8CPA0TSgZLC1Vln2Vl+Bim/K0tbC4Eks37AjsSzyRh9O8VWUDgK3u5JBVmoNMKzc55xVC3AjDBEdzm38hD/5MHXMRpWxnKXu+6KfX2u6cW18Ivq6Bno94vGQD9+8Pe94m7dlv0og8PTytFKpYDJsbqxzKH7VHLgQ4kF49fvHeBoyc+jjuTTmsa1JGTn0c//33OcbXiY3eE0q8cJp04wvSax+buwojpz6ONVuaua6wmQgPDBiGlA0wM4HwqOJaq/JRITGBh59v2PJ0y+Kd9ttnGzFy6uOluO4eD7+1EiOnPo7123eXjnWuV2vLqnKKsWMC5dR83Ofc/BImCu3onRWbcfZNjqveio27cMkfX9dKa+TUxzFy6uN4a7nfpq/lB+77P3h+kTGtoFi6HPU/T6eXWAbkQoCnqdm+vtgZa737taWppem1o6R2+r8rPAm0MneRaVaNnMcMz99mOYH3F67Z6otpEYdyeNfgPp72Uj6GH4qQ1XNMap0XZFn7gYfh5fm75xYBQMn908NbaGHp+h2hGnjU2qAqDT3UCYUzi3gsWL3V53kFAE+/55+puTAidIHIswv8U0eMbeAyBaHIELcfGSVnalEZz4UAB9K3r2XtW75MYqbQ4Zn5a83yFrJuNxDE5eW2EggxIaOoj1jAFltk+N1zHypdMMX7kMerSNY2GBi2Nrfid899iGKR4ZF3PsK8j8z86OPk+vriDVprtXo2cOmiHYpbf/Ld1bjrlSV4fO4qAGaxUHQ9kkxDDwPOgicehQJhyfodpd5w+EeF4ffPf4jNO8PXwWxnTKvtPzh7ZWSsHFkZao36ahdAhyziRyRNU3o593w/fftreOP7E6XXMsZCBxmXTpscu1xt7foaLh/hL6knjejtoPooiO/8C41N+OW/30fj2m246eKjtfPx7TM5V2JCYQz42WPz8UDDSowa1LMUIMv3HIx7DIr9XJ4X31E2OQQ15PKHOExQqrwkvvyXt3y/RdNVmHeFrnXF6xnosmLjTvz0sfml3wUCzv/ty9jW3IbPHj8i9OP/+uKN+MVT7/vLKRvELDKtNvwd11yZ5F2rBfKjgVe7AAq27GqV+kBvDpnUE2ecZcuuVmxtDqYpJlXSwDXS9IR8sQifDdyLQlcsMmyT5OlLI6Q86i5uGW+l+B0t0Zqoh+iCuLutiGYNTRYQTShls8yO3e2ltHRxnr38YYq7d7W0Y8fuNuxU3KeYClfK0vqVcq8LJpyvR9wxDx7R7BOFWLcFImxrdp4lYwjcRHNreynapq62315kpZ5lXGpR01aRDw0ctenCM3flZpz/21eMrysyhjoDXfeJd1fjK65G9erUMzCsb7fSsYAJxcAFjPeD9gTBxh0tOOonT+M3nzkK76/Zjj+8sEirjGVba/iDEgV4mD+ytMwEHP6jf/v2nTTtWWzZ1VrSpsLMY3zuvrMM3/nFTdtxxq9fwM8uPByXjt83cFzUcA/54VPKcsjO5/F6VTINVfe1CCYfZq9wNlFtqNXgYwcE75G3CBVZ8O5GX/8U9urRGbOvn6TdARJNKGG9XVNqUATlRAPPwIaS+CsN4F3BTqr7kTGdHPDKh+VFVcUYD2Kz9zwWdO6Pd2kTBe9LjevxrzmrtNMQ4c0yPGJXPsrnOCxYlodJ3GqpG6Li/zC8aHwzF8jHLKLSMRlU9DTdMA3cVLqEhQ8um9PC25BpT1L8ePOCVWVy2+BO5JIH3QoOSLcX/QI8Ba/CmiYfAlxg/fbduPbhudrdZhmm8vujzbtw/T/n+QRQ4CXUfItMexNhwvgOIQ56m4YJpZxceRBTbOjGHzivK88Cu3yoYpmohMWKjbtw8zONZmXx8o/ax03PN/2c8wPA/vT1BKpsAQz/7/L/3kfZ2/Xv99bgL28s08pHRagfeIhw//XTZTu0qdeVKMD5QVnGwtPjQ1eU8y9TDnbmn4nJGMN9byzHv9+Txza//83leGreaudHRtM47n19WcBjJy1yIcDFer3hiYW4/80VeHzu6oqV4TsPzME9ry/Dm26cBUL8LpXMEyMMsaHzzF3p7wWYuOnxbnRh3dvQNBQxtVV3FDChCGWR8ZtnPijnl/Al4ydylSfpxEioJPzlh6N6WeJhVTr8UmWekP/iPbPxg3/M811nKkyLpfDBMs1Wfd2tz35olA+P+Oz5NsbAQvONcrH1kioW4RMYDM6CL1+8Z7b0umsffhdfuvct6TGRuGbc6/45D1cp8k9KLgS4RzCmsf/3h+u2ac/EWi6sHP7R5l3Y1tyK3W3tWNwU9Jsu2ZaFr3scVHZrGeLiuFF5ehp4WDjNoN2ZlV5oD10NXPSljqoSlTfE9t1tWL0lenamTpXzHjVhvSTiNPBy+uoM1m1txqYdLdi8s6UUT0Y832sfUc0wKMD9ZWhcG3RxkyUZd3FnHTNeVAswzbOtGBzE5NMyfZt8HkWeCUXoTcWJZZInq0s+BjEVvsDis5l444u4esIoXDPpoMg0tzW3obm1HV071QFwBsJG9O+Og4f0woz5a/H+z85Gl/q68gWSbmXcL7JuaM9FTdsx8cYXffuisuS1+bVbmzG4d1flueXp6cEy6A78lAdCmW/rpSui+sC+1LgeJ9zwbKRbl06V+1wZA6YKeZo69zvu5zMBOEGlVC50peh/URq4YgIWANz/5gqpV46JC2USyvHAw88zFY6iF0rSwUX/x9jpEzs2cHWPtaORCwHuwZjTqEr+y5LmK07PDaO1vVgS4ICjlXuaebCr7/zmtQbl9OQIAnEpFIP5sqiBUXm0cYlv2tkiFeDeLXgT+2QyVduEEjLIKHs+bQovlChKU8Y1Lgizw/vcCLl9JqKEF94qIRZVzrBBTHFwnDsrsMf7YPNHdOpIxwYepYObCkfxo1cQlKEk7nsmzzJ+PrX3NdAyoRDRUiJ6l4jeIaIGd19/IppBRI3utl9WhRTtrGGR6UyejXfqDyWxlFU2yrARbt2sxQakMqHIZt5F2TrvemVJuXwRXl7l7j6T2MDNtCOZM4TstsSYH7panHeWzvn8OeL5O1vaMfmWlzB35WZpT8703Vadn8Skcf+by0v/809BN00dM2KYFwp/7NsPzFGGnTAVZy2CBs63b5kbYRRSE4rgBy5rL3Hldy1q8yY28NMZY2MYY2Pd31MBzGSMjQIwEwYLHZsSNKGUBY+ISTPwLr/7tWWBY0HtWtYQ4j1R8f1SvXBxXB1fXVQOZh8p7LgxvKAXil5+Yjc40kZvOHvPw6sjnSEO3rVOLM7bKzbjvVVb8fMnFpQVA1Z2PUsreFVUKvqDmMSVLYjsGYu9HBnl69QPmgA89NZK/PAR+WIkpu1fnIwjuhGaSnD+dO9Zim6EUk+ouA+tBkkyiHkBgOnu/9MBXJi4NBGIPsONa4ODjSZtatXmXcqV0lXadZh9TdagV27aiYVr/Hl8IAxQqVbPlgnRFz9YX3oRTLvpIiX7tUQDN7VPMnHL5O+DOHtvUZNezBivfDraJX+GeF9tXFyRUjtatx3Pv9+kVQ5ZuZZt2BEYbI4qZ8AGrjg/aok60UMF0BPg3unrt++WxO3x3rMIE0pkLn5EAe43ocjnDejCD0irBjG9+Daq6snjerm6ApwBeJqIZhPRVe6+wYyx1QDgbgfJLiSiq4iogYgamprivSRiM/Ie/P9J1pk0EeDn3PyScqV01Sre4uwx3zWSdD72v8+VQm568DEwZL89ZCaUP7ywCL+Z4bjVRQmJKA3c/zFKZkIpp8P/H8xffIlvmann413SwLWEE29C8R/zhFuBCN07O0NAd7+2rDQZKMw2Lc8LOPWXzwcGm6PqXnUbYv34TVLqXiB/pF2jl8OndeovnxeOOdvIFmAo70QTim+xBJi9uxDO5/3ARTdCj/NufdnNV/WxDKbrO25WvIqgO4h5EmNsFRENAjCDiBbqZsAYuwPAHQAwduzYRHXgXRwmXNL6igZeMMmgTyCnlJ+w6j69BRmiNK1IAe5uHS8UMW+tIpYoZ5WNCcUrn5YJpeiVJNiz8D4EdQVC53rJAgnG3Xj5BVEfV/G4V04xOqFPA5ekIwsn2xo1+IHwetStAlMvFPH03dy9Mom5SyPF0n/+QUxOMTGY7Z+FjVtH4UiC7qLGq9ztOgD/ADAOwFoiGgoA7nadOoVkeHJs1A+exMYdLeECPKX6UmnXntZ6y7MfYs2W5tBrwrhxxgc44YaZRmUQSaqB8948YkMraEpw71H84YVFeGzuqlL972ptxy6JK1ycEKRA+UXQWRAiTGv1TCj1BZIKX3FPVEdEpbGbC3BnK9bZ+2u2lwKjMQb871Nl3clxM30hMm0ZodEIBVOl+rzIbELz5N0Kj/rJ09KVonT459sfYZsb4Ky96C/3I3OCMziVGri7nbV0Y2mhExNOuGGmb6YqoPcxTUKkACeiHkTUy/sfwJkA5gF4FMAU97QpAB7JqpA881dtDW1YaX3vdFwE31iy0ffbZDmnW2Y2YnVEA1Ha6tz90Rp4eBlk0QjLx8KvlXHzM42++pfdn459VoYnuHU0mrKLHAXuy3NlUykBpgNzKmEQ9fEUJ7V454vRCvl4NAwMtz1fDi6misOi85HUmsgTJcBNZ38GPnb+HTMXmOmA3uU/f2JBaV+7EE72Z48tgIj6vfI/g1lLN8pPVLB6S3NgpqppyF1TdEwogwH8w33Z6wHcxxh7iohmAXiAiK4AsBzAp7IqJG+rJYoOspMGXuN4ffEG1BUoxDe3TBzZ9FfOZUzEVIsTiRzE5AZ+xJexwHk/8LS2F/G3WStwybgRzkCgbz6nYAMPKXNre9FoWbuyCUXfvivrWfAmFFkBTbXKXa1yYRn5cRUu88osauDtIRXau2sned46QkNxyspNO/GcO6ArKigmyKIARg2Ux53Xw8dEKjKGOm7lIlnI27grzce5THSbTZtIAc4YWwzgKMn+DQAmZFGoMPiJPFJS+uB5D0scYAzT0OK4FU59+F1pOkSkbGheQxe1OBHl9a7Q5f3rxVPrFG/TnS8twf8+tRBEwGeP3zdY9ogH4JVp7sotgTguodcZuBGGfURKg5gFkn9gDJ+hyoMoqqcQ1MCd7W5hEWb+Iy2m2EslwBPYwD/uDvQBwO0vLJafFJEG4GijfNhj5/zwOjGOn+ZumzlTTHuRob4QT7ERd6chSrLWwHMVCwVwhE6YfTa9QcxwOxmg9lRJnre7TaiBq+9BsHEymXYkT3PDdmd26E53AQQx9nKUF0rcVcPLfuA6JhT+/xAbuCStuNpZWBnkx8W2I/9A+WOk+I/16irXv1ra4tvAN4UsRCISprDInnNUe47bs+a9W9pZtATQXYQjcDyGbIk75qNLLgQ4LyQKFP6lzmoQs7zf/BpTvMav0gafeHcNZi/bGNlVjp6J6eB4awjHFJXMa7AydE0opjzlhuOMEgKfuf01fPU+J7rcrKWb8J9/fMN3vNUzoSjuT0w/7iONNn+J+ZZy9O8P+RhJ18iEWmjsbGnDyKmPO2t/ptBWnwmxWcvSjx6TUaSluHDjjpZAmNhiMTyqYXg5ohSi8HRlxPW60iUXApyHiEK/1GlVl7KbFaIRpae9udpYiAB+4f2mFPzAnS2TaOBKAeeeV1/wzDBlArlJso8rwEvXR9xTlN223a3UQoGkz1hVPlPdMFqAi/7ezvlBrxa1CUVVFaqlzjxvlnteW5a5T7OsbCqXTg+V0hDmyfHEu/6Q0mKa+w/sEVkOj7C6l/3WIS2ZoCIXApwX2BShgc9etglzVmxOnGcc74K0npWOuaDIogfKHmhYgW/c/7byuH9VeiYck9dzyYujQLhxxgfYuKO8SnhzSzt+8e+ymxv/v4epjVkkqV+tpxHVK2zgaZnB+PuUacQ3POmvG+90MXufDVyou+fe92vAO3a34RdPLcQOYc1QDz5cQNbrPnpL8a3avAu3zmwMmNeAYPtWWUbDPoayNHlTh0wD1jGPpkXWAjxX0QgB5yGrtEOPC373SuLVplVthlcGRJtYUu2ylA4LN6EATsOIyu8xxYIXpUFMzgslEA9c8TZ5muPbyzfh4bf8PrartjRjFec6uH57C0SS1lHSKuY/QPL0k2XgXc6n84Jkmv6yDf549OVel9qEIpbsTy8v8f2+5dlG3P7C4kCoBo9y7Jdo81pS/jprBb4/+RB84e4GvLdqK847apjE7i+WT06YohL84Pl3StubsnetzCbyuNKuHp5kYvKhgfuebHkChqx75LF9d1vJJWtni1wjCSNqABAIPlBxtfS4rNva7MQnCWm4jgae7C3kV2XXHcTkp6LHIUsTiujBIc/fjYVCchMKXw/rt+82Euj88+L/79dD7i3iLxdD07bdEjMJVx5JeGEeb+LJjt3yevBH0vTntHlnS6IlCmUUiEpmm/pC0Cdftze1bqv+hBpxEFP2jsiybW5tjxykDDuuatdZ93RyqYGXeqQhdcOvXP675/RWVudRVXyYRvSjR+VR20yZeOOLmHbREdirZxflOToaeBRhwaxUAtrrksqmoesQvdRYhF0/5J4v//OsyPy9D1CdYiYmn/zYnz0TmR7PzTMbORfPckL1hei6mv7qUvzznVX46QWH+fbzz/i/H5wbmsYj7ziTfqI8HxiCQmzM/8yILKMpBSqXpb4u6BYb8BBSPFsxzgxPwBNMSEPXhPLJP7yKL55ygDIfJy/1MZVikbH8zokGzv/P+Uer6sY0jocMnUHMLHljycZQAV0spiDAuTClzcKElCh7ZOe6eE0neuA1/PqwD8Brizcoj3l4L3SdYhAziQnluffXlU0ovDaukeaLjesBBKMzxhkzUAlwPvZN9p17Jx+vLO3FYI9SfNZpeGy0C14osrqQPY95H201DgGscyzjUCg5EeCcMCGUhYBKmPbokrxj8fi7q6XaHp9llgMUdQX1RB4n7+SNg7eJilO4lRq42yXtVJeNCSU6/kusbEt4Hg0qF7wkg6RzV24pfUR4wWs0e1Q4d7FmuF2eFpUgLN1y0G00C254ckFpzOFHj7wX6uMOJDcJAq4A50SxrL3FVc68ow/NXol7hEUuVO3aeqFIiNLAfWtZxuSmZxql7ku+B5Lhs6mPFODJPQnKboQsME6gctcsaeAxTSg6AnxE/+6hx5Pg5a/6QKXmhcI1HRPNMo38I00okjGPLLj39eWlSTYzF64LmlCEm1V+eEIQr2gXvF1aDQR4ZF7uhd/++xxcLyxyUS0TSi5s4LwgKXKDe6rKqU/DhgKV/az8f9Sz8WJMx2H5xp2hwq49DROKu3VMKKIGjtL6oB7zV20taeqd4ppQIorMGNAzpAeV1EV06XpHo31v1RapEDOZ3h8Gn7ZJBMU0BKtSgPt6j4mz0YL3SY/yQkkjboj4Toi/V2/ZhTWKQdGoqpdFJ2xrL2Lhmm3Yp59c6bAauAADF5lOUTmq7rEpMgFuovVOViwWocOrizZEauCJTSikNqHIfInPveWl0pJtcb1Qol7SqLURF6+PF3LUY44roF9qXI9XPgzazJ9RRPgzhRccWuFdDWK9RCE+y1IebtoMlRvL4VHFQPeIZQOXmGX4XWKeJ9zwLD59+2vSpJ4X/OrFKvq1u5AKz80zG3HerS9j3qp0Pvym5EKAi/E2PBmg1MBj2mdF5JHM9K9fuWlXovzDTIJFlvwl5P3AxZdeXD0lcG3MPFXCxSON+6oFeMGhtcSZt03h3psU7oYl06NkUk0lEHsiogCPEztbNhcjbh1+tNn8ffWWaftI8a7biTwCn7jtNYwe0iv0HHGSRFwm/Pr5wD6+wSxJqA1GEdb1fvGDJt/q5XHwtOifPb4Anzhmb9+xW4S4xmkR5ZNfCdtsJeDv47E58glVPtzT/zprRUYlAi76/aulrKpRz0EvlBQ0cAFnEDMecXru9a4pcbdE2fvkba9i9NBwWZWU3AlwAFi4xplplrWmtrU5KGyynsHGEzYYFUdbEOGb67ptZquPxO3qR2ngrJj9wE8l4DXwh95aGXl+JW7Zs/2yFDyY4iD2RMTmnYYNPMmHSRzX0fkUeONtsh5rw7JNaFi2KXZ5dMiFCUXp9lPZYgDQbyBplE30zU4b3jT1pmHwfjEKnC7RJpTgpKJawNTkb3oPac3i1YExhjeXRPvMp41ojxYVMJnHSBQvfbDe97th6abYL5+ogS9cvS0wH0LsRdSFCPBKoC3AiaiOiN4mosfc3/2JaAYRNbrbftkVU0413nPdPNPoHaQ9tVmEjwey27ABzlcsZBCFKtCSR9QgZrUwfZxZB/JPAgPwQEN0ryBtogcxzYXgNqE9PT1/bew1AcQZs7e/GFzQYqfwTqo08EqN45ho4FcD4BeYmwpgJmNsFICZ7u9MUD2QarzqupMN0uii7jYQ4H+9arz2uZ422TUFf3lToj4UHWUQM+uPbxK2SUyDlaDIGHp3rcebP3AW8hLldVofvbjNR+Z+HPAzbxc1cEeEtrSrV1LKEi0BTkR7A5gM4E5u9wUAprv/TwdwYaol06AadjzdPNMwA5gMJMYZgInrCpgld7y4KDCdPI9kbf7KI23tDAVuHdWACSWl1Wvivnqy10FMazcnqB+ds6o0I1nUwJOGTdZFVwO/CcB3AfClHMwYWw0A7naQ7EIiuoqIGoiooakpGFZTB/XU11jJJUL3y1rpspkIY69stWis+ONLS6pdhFTQiYy4p9HOmG+xbN1gVqbsitn70Xm3d3Mf5j++uLikOIm9h5rRwInoPADrGGOz42TAGLuDMTaWMTZ24MCBcZIISz3l9KKp1IMxJc7cpQ5gqagYD79tZjMWV5e3OAOABSp7P4kWk7TerahxFhU6vWZ+bsi7H20pmV1E02Cl5ISOG+FJAM4nonMBdAXQm4juBbCWiIYyxlYT0VAA6gXyMqKWNfBKE8eEUpt3Upus2GjmttlsNfAA7cyNseOq4Fl5G+2I+fHU6QGozDzieFXNaOCMsWsZY3szxkYCuBjAs4yxSwE8CmCKe9oUAI9kVkpV2eB81b2v4KBeXXDyqAGZ5lkp25YpJrFJyqvR1+a9dASS2sD/cOmxKZWkdmgvFn0aeFaD1TtjauA6Qlf1XMWJPJXyQkriBz4NwCQiagQwyf1dURhj+NK9s0tfzqNH9E0tDoqKWtXA44R3rc076RgkNaH06FJ5D6GsaWtnqONs4Fm9S3E1cJ3yXPi7V3y/vUvEQcwv3RvL4myMkQBnjD3PGDvP/X8DY2wCY2yUuzWbCWKSb8j+p+c7wYf2G9ADv/nMmMj1MpNSuwLc/Ftciwp4DTrGxCLpIOaQ3l21z73+vENDj3fvXBsfgyJjvjDFWb1KcW3gcQZRvR65KMBnZzwD0yMXMzFV8LOixuzTF9071ysXq02LJCFis6TeQIBX2wulS0gs8bRCAVcbHRPK4cN7K48REQ4a3FMrr1MPCjcbHjOi4nPspDyzYJ1jQ+bi0GdB7EHMGAL8vjeceET8B/sfhgPeSciFANeZSu+99h3k/TemU45uvH+PzspjYbHA84TO1Oow108iEw01mE4vrh6zVmpMWLdtdwVMKJXTwD34533N3+bETseUXAhwJRIJHmYDHxCySHDeMR3EXLFxZ9VMKP26qwV4LTyjcSP7J05DZ8YuhQlw6GuEsmTGjOhb+j+l6Mqp4RUnbfndu6vz0YqKt6MiiVeMLPR0Jci1uuOX306zCNNqOsIUbRUmMdB3trTj5F88h6F99O2saRKmgWdBv+6dsGmnvukrjXjyOsIpTDEuECXyeOJNUVkP7JuSlRthzy712NrcFjswWJJwtjUfzKqaKGOhcA2ANDTwWnUBTAOVBn7RMcOV16yWLBFVCfp27+T73adbJ9z0mTEAnAkR4vGk3GbokpeVwJt85FDf7ygTiq6JQZYKPyZSayETyhp4uu9jd9dstHN3FTRwK8DN4avbq/uwxppGwPhaRSV0hvXpprymV9fqdMBEDbx/j87o4wrtXa3tGNK7a+hApymmCzBnJcAHCPftZSPLjkAGJpRgArwGHnf90qwoTaVPWebVFwj1BcL7a7fFuj6JDdw0mmda1NaTVaATC8XTxsMEeFrBcmoR1V2HCa8enasjwPt0C2rYndyobs2t7agrUKpao2laabmiir75KvEg+2AQ6fcYZaXlBy5Fzb/alN0I01WoiEgqhG++eIzW9XG8UDysBh4D3rTiNfYwZcNk1NtUa0uDGz99VOxrVQNiYfbcapmUencNCnCvnNua20qaVFy+OXGU77dpSmGDi0bpCDmrqlv2gXFMKJr5SDV4h08eu3eqvZk0UAWzSpyuYv8Rw/toXZ9kwWwrwGPAy2Pv/7Dur0kXKcnXOC5ZdN07FdSPOMtJSWE+zr27BTV/vpu/cWdLItc3UXCayuO0fNFFzwSVwJILcNIWcOL9etc7x6oTdlmHtMtFJJ+RLC7UkAXWhBIHnwCPNqGYIBP2l43fN5W0VSQR4KorwwRhlgL85/9xhPJYL0EDZ4z5XrwCJdPAxSYgE3BhZGUD52v7sGG9Sxq51IQCg0HMEA3c8SevLQmemQZOcmFdVwE/ymq5EeZagPMmFB0beFLNqkfGk0yS2F5Vl4bdchqLyKoIew6ywVP+xasjSvVjZlqtWTlt8PKqa6e6UuuV3WqBCAN6xne39O6BQDXnPut9UN9evjn1dGUmw6zDa1STXAhwVQPkd3sj2mEv/qXj98V1kw+JXQ5du/gJ++8VK/1EZgNFIw31yqlS31r2IexcXy4nUXV9l7Obzl+ub/7+VIOY91xxfOycSjOTC7VnQokjT3WuIQI6SwbBKmBB0SILO3mN3Fo8+HbZrqGBb9jRgitP3j92fp01u2J/uOxY7D+gh3H6WWgK1TKhhNGtUzC4Eq+BF5Jq4KIJxTCprKae825zdVTWjFUmlGF91S6gvnNlJpTSTn1beqWIU7s61xDJNfBa8YPf1px+HKVcCHC1G2H5gDfoGOaFctHR6kktOnTRXAS4Ux2he4xwoFlonaEmlAwFeNg7I0bHY/B7yyTVwMXeiOkLnNULz5v8Lj9pJGdCCTFiayDrfflt4PppVYI4Xj461xDkNvBaEeBbM1hMOhcCXIXfCyVcAz9ieB+cPlq6bKc2XTXDctYXCrG06aQC/IunBnsX1bL/hQ0cykxRfNeXQKmW27TrmtSEonJb4xWRsw4bUvoty89E6EjPpPKm9mzgaiYfIfdZ19PA5V4otWID35pBJFOdNTG7EtGbRDSHiN4jop+4+/sT0QwianS3/VIvnYtO8/OEuar7a6JtqgRpd0nXX0Z9gWJpGUkFuExoVkv7CMtWdp9iONwkZoyBQkAsncBSPEnnAKgW11A1wTANWge5Au/sLBi4I1aKsLahOqZlA4c8rDLViJq6tUomlN0AzmCMHQVgDICziWg8gKkAZjLGRgGY6f6uGl4jFb+2Y/bp6xw3EOCqF7CbpgZeKMSz4WYhbKOSzGqwMCxfWTdXNKHE1YI71xXwqbF7+/YdM6IfbvvsMfjEMXsrrvLzhQTjJIA6Nrsqpo9skC1KATjpwPJAudwPvLxNe8p6UsLuTfUOaJlQiKRhA2rBhDLlhH2xb3/zcbEodNbEZIyx7e7PTu4fA3ABgOnu/ukALky9dKUyRJ9TMqEIL/6Bg5yg+CazDlWTX3QFOBCv25aFMI1KM6v422EmFFmZxDqP+9Kdc8SQwMtORDjniKHay87t07976PGoaIrKfJj8p6ytRJX0jNGDy+eGabSoPT/wMFTNVcuEAnnd10Iwxi+ddgBG7BXeruKg1bkgojoiegfOyvMzGGNvABjMGFsNAO5WamAmoquIqIGIGpqamlIqdpCSG6HQmr0HauJx0UnRhdYxoXjCiZdHY/cNWpdknhiJTSiSy6MEIRHw8aOG4dpzRmvlsZdmKNhwDdx/kLHgKj1phHTNim9NOij0OF/nx40sP/svnOLX7K89ZzSG9+2GQ4YGZ62GPbfrJh8SiPEtNh3vZ6FAicd+KolaA9e79rrJweXlakEDN51MpouWAGeMtTPGxgDYG8A4IjpcNwPG2B2MsbGMsbEDBw6MWcxoyoOY/v3ewzMR4CpBqqOBP/zlEwNpnHHIIPz2P4/2nfcDiT96chu4ZJ+7c9Khg6VmCQJw6yVH44unHqCVx3Xn6fnRh92J7D4LBcJtnz0m9Jxa4ONHDZMKXBVTzynXl3jd+P33witTz5D3gkJu/8qT90edb9AX+NWn/HF0vOfetVNdxRfJuP0ys/C9PpQauJ4RfNx+wcU4akKAZ1QE00WNNwN4HsDZANYS0VAAcLfr0i5cKV+NYUymGMSMI8Cbtu2W7tdZHNZ7UFGNRjbLLovRck8QMsYi/IX10H0ZTDRwr4fClyWLukjDklBU1CMPX0eyiSUi8ufibFU9Hl/9UPDevN/VCGSV5Mkl0cBVp9SCLpCVFUvHC2UgEfV1/+8GYCKAhQAeBTDFPW0KgEeyKaIeRcWkCO9nGpNW6jSmdKlWBhI1iBGSAY2kM8bCTCiMKQa7uP95DVidh97bwNfVqEE9hWP+NH5+0RFuWdXnpEEaizgXiyxSQPFVpGMKkr3c3nN7yO3RifAfQQIF7swLnaw7dyFNkkRzjLKB33PFOMy45hRFvvJrq9Wb+w9u3klWC4jriIyhAJ4jorkAZsGxgT8GYBqASUTUCGCS+zsTdL5e7QovFPF4EnS0Qu+UOuEF4y/tVEdSYZ3lRB7VQNaGHS2l/wf1jl5iTbeIfF2JftHiC97VHQ/gP3qZCPAU3qH2IovshTS3lleE0Rk4lekW3lW9JbHTAX9Pkyjo691SEuAdRQN39h84qCdGDe4lrVeVmSWt8MCmFIgwROOdSkKkCwJjbC6AoyX7NwCYkEWh4tDc6jRY8Vn179EFl4wbgc8ePyJ22n++fCzeWb7ZyI7FN0QGv9bGmLyhZjKV3k2zyBD5ZukOFOlQ53ML1LvG+6gREaZddCRO+eVzWtdVEh0TyuuLN5b+11kNRzbRpuQGqLjGr4EH50p4k5e6dKqCAE/QjFVtxdsd9hGe9gl1BMxqoVPuJNSIi3s4OvfuxRkQNTcGhhsuOgKHawZ1l3HG6MH41pkHa2mFZRt4+HnSZbQSCvCwiTwa8ltLc4qjgetew99/Fi5XabxDbUVm5FGg8gnnkfUOvTxUTcKvgVPg5rz41CYmlO+dreeJxLP/wB44aLDfRJakGeu6EYrPYGCvLth3r3h+1sdKvMTSgFfcsnLkzIUA12GbG2dAFLJpLsygJcDdR+abmCKYUD5+1DCFsE7/MfODmFHoaNf6NnBegGtq4Bl3ddPQgtraozVwnk4abUZWrrIGLr8+4IoptJ2SBu6aUHh3RhVxls6ULkYRw4jSz10TNclEnricdlB23nFnHT4EQHbzLXIrwL3nOdyN2OZp4GIDSHPZMD0BpzrX+T1qUE/84pNHVmzWJd+Fi8pSp0i6Zh6fANdUwQsloZUNaQwktbYXjQS4juBRhZN1/om+hhD8CIg28HuuOD6gKT/8lRMx6wcTuTTNxYH00Ro+wEe+ehI+NXYfdXoh+z2SvOZfPf3A+BdHcN3kQ9Fw3UTpOrBpkA8BLu1iOuw/0Ok2edOzxZchzTULzEwoJN2/V8/O6FRXkDbIpN8aWenKJpTorr+O5qQrvPwauN416S5knFpSPjrVFaT11FVha9YpR5gWq/Ss4A4QBU01ZRt4nVu+OvTt5ndJ7NOtEwb2KvuI685UjS67GYN7d+WiJ1ZeA88qfDDgvAdZ+uHnQ4BLKK35R4Qff/xQPPK1kwAEXxjTacRhIWe1vFDcpqgS9l6Dr9TkAq8cxaK5Bv41iWaiPYgZw4QSt0ouP3FkYN+TV8tdzZLy608fJY9dIoitmy8eg/u+cLzWvcujEYZfUyeY6C4YMwxHj+hb2ieaUNwThTKL5TAXB0Tk0y471xdizC3g32dFPpGpVC9cwC8+caT8QAWKlFsBzjfwy0/arzTLLWBCMbSBf+tM9TRpnfZdsl2Sf5/3s6BoqP+RMFZ5VHmKLNp/WeQ7Zx2sTC+K+gpq4LIJVgcP6RU8MYUXytEWo8t5wZjhOPGAAVr3JNMA+UWJZYgTeTrVFfCXK8sr+Oi4EYqCNk4AsQKVzZgA8Jmx+5ibwKjcRpJM5KkGFx0zHIcpFvCuxCcltwL89IOd+A7icw2aUMyqMeyF0xvEdBBfBlHDEPMpsmxc/XkvlDTTMzlP240wQguLw7lHDCn9n1YdyMqneno6oUxVIQ6cvOSV4XMjLI0dlPe1aHihRL07OhSIMJQT4BMPHWz8/AjE9UzVZ4Vx2fiRZpmmxLmHD61q2IdcCHDx1Xjy6pMxXrHuZMALxdCEEiagTAYxVTGlVSaUVJxl3DS/OXFUeZe7dabSmze0z5+0n++3rgCvj2FCifseqJJfOm0yfv/ZBHE5FJiUU+fewwYxVVf73AiFawC5H3hUSXjPKZlZaum0ydJy9u7qmFCuOmV/nHrQQGMvlLoCKRUbPh//jvK/3z37YFzNtflK8MAXT8DSaZMxURFjqFLkQoCLFIiUL61MszUh7H3T+9I654gTOMSXTGarz8LZ33vRnan05oj1oW0OkWiIMvhYH3EHqnQFRnor08g0ZnkZdOpLLsDDeyN+DTx4rswGLqYl/o5lAwfQq6vjIud5gpk+xjoi8GNaqnx8VDlCLi9XVJO1+nXXi9yZhFwKcN6mHBQwognFPG0VJlPpOwvR4kSNSmyoJsLljohob3xSvqn0XJYqrwmRgOITQ8iGXeENPgOcG2FGCk0WJpSpbhhe5WINMTXwUl6qD4PU7FLet1sSC0VMS/wdxw+ciEoC3FvzUefxedcAjpkp6tknbRN3XX4c/vnVk0ozspOmx5tmR/Tvju+fOxqncv7kl4zbB989OziGlDa5EOCibHMEovwJiI3QdCJP2Aun89C9U/ivMgO35JvC1lcs6vspn3nYEOn+krlEsrcoaOA6U7yB+Bp4WBo8e/crz7iMO4ipe1laCrhXzmF9uuIsxbOIk54MLQ1ccq7OVPpg2nFs4GUTijeZTieZiYeUF6QoEEU++6TxtE8fPQhj9umLS8aFh9TQdaXkl2gkIlx1ygGl1b8A4D/H7VuK8ZMluRDgIkRqQSJORjCdyFMgwnfOPKg0M8yfr44G7pwj2sC9LheVBHjQ1LNPP/3p42cdNjiwT1Y8r57EWtANciSWM0uf2bhaUaUtkKT4X4ZYfxNGD8JpB/tn/l149DDjMtRJBzGDZB3MqkBUElyfO2mkWw5DGzhRpGLw365HVNRqSFGUBsojjkchUwxFz7NKkAsBHtRMSVlD4oCCuQYOfO2MUXj7h2caXec563u5+6fSc/HKFYM1DECPLvXSgSIZt182Vn0u82sHzi7/IKauBh7mO6xb1iwmYejmnQUmL6oomP50+XH4v8+N8+0bPcTvhnYK1xVXpS9Gu3TyCp7sM+VF2MDjCKACEfr16Iyl0yaXPcMMHzdRdBv5xLF7Y+m0yYm1Wj5gmgxdjxLZIunVWDgiFwJchLeBi4gPYO+I9Q2DaSd7CDIbOFC2cZe0JaHm0+jeh8X7FqfS6668HrCbVqCNmmpwnu01ikq7Upqe67GvRpuVuhFyWY10g4Hx7TkosEWbuDmy2zNNp5JueN6YwOHD5L7buqEi2iUrRfO3UallSHMhwGU2cNWL4TXs0UN64a7PHYdvnGEW5yBpW/KEj6jhBm3gggae0RPnp9Lz3Wld16c07KRZ3ZuHF3mvGuWIDE9gWF33XDHOt9yeKn2ZfzcvkB/68on4x1fki0GU0/Zj8rG55ZKjldfw5Xj8Gx+TXs8/i1iaa0xhOXKv7rj1kqNx6yXyxUv4ongDrV8/40A89c2TfefJnCOqEXdcZ0WefYjoOSJaQETvEdHV7v7+RDSDiBrdbb/si1sqU9m2Kzy80tRxxnD6wYO0wnnymDQm2cLE3uVBAe6t2ekJcEiPpwGfkleeYtFfXl2XMbE2smyjcatAVzCn7YVCIe6s5XPNKuzkUQN9ZgLV5fz6rLJz9urZBUeP8L+SafamStEDZWEFSu8A4bBh0WGcK+lGTUT4+FHDlOGK+d7ABHcx6L37dQuYudokGngV5LeWBt4G4NuMsUMAjAfwVSI6FMBUADMZY6MAzHR/V4RQDTzGKvS+tA0eQti55xw+xHce4/4HwifyXHTMcJyhuZL4DRcdgclHDAUAfOa4fXDgoJ6+kfaSAGfMJxh0Fmjmr0+CqWCOyvNswfMjCwX/e2ePxqXj4y8CkhaqqtBZnzWQVmA8Q0+gXzf5kNIApQcTepT+dE3LVQXJB+AbE0bhyo/t59vHC3DPzOjd6y2XHI0R/btj9JBeOO2g4PvJ18UoIfJjVuisyLMawGr3/21EtADAcAAXADjNPW06nMWOv5dFIQNDmNwYpnjM80KJO7Mx6UCEd3m/Hp3xhZP3wx9fWgKgrCWqpovzGviNnx6Dlxqb8OzC6HWiLxk3oiSwh/Tpime+darvOL8mJi+0h/bpindWRN9PcG1Pc9KWr38Q/OC1gxAYFOTLpx0AALj39eXBZCo4iUQl3LqG+Hfrpx3+2+PKk/cP7BO9qnTS0SpT/EuN+dakYNwjXwgIeOZHh/OPGobzj1J7DHmy/5zDh1TEhRAwtIET0Ug4y6u9AWCwK9w9Ia+nMqYAHztBxLPtVkIDP3nUAMn18gTKJhS4W/95R3M+pLLjcSl/6JjPhHKKZhD7oAkljg3c+BIjdB91FtFmslYeVcmHzXQdt19/6TXHBEwqfob0Lsc0OXSofJDPw3um8vKpK2X8/vKyJUFcNDsJ/jj2zlbXvMkrS5VCe5kIIuoJ4CEA32SMbdV9kYnoKgBXAcCIEfG6pIFBTCpXrmj/5G3gcdAVnM9/5zQM6dMVo69/yl827n++CJ7JTOYHPuOaU7D/wPSWpeJRaeAXH7cPrn343egENDXwZ751Cnp0qUdbO9NaiV1GlWdHxyLr7r9O8vwpL/736RjQS+4r/Y0Jo3DekUMx6TcvSo+PHtILM645Ba3tDIcM7YX/fnCuMk9RIZGVWewZHDOiL/58+XHqG4nBPVeMw8mj/MoIUXwhKgvCluKiXqmjJcCJqBMc4f0XxtjD7u61RDSUMbaaiIYCkPb3GWN3ALgDAMaOHZtaVURp4HGXUtMV4CMHyNffk7tVkcQGXj4+anAw9GlqGri7LTImDHxpfoDF34rLDhwkCd8aE9M7r6TGI5J1l99k8hgQvpZoXYH8bU1IuiAeDyGODXzkgB7o3jlc5Gg/SvdEWdhgMklHQJy/4eRlpoFXEh0vFALwJwALGGM3coceBTDF/X8KgEfSL56D2PUNc/z3upZxl1IzHRG/94rjS7PEALk9koEFvFCiXkzvaNI2UZrIA+DHHz/Md+yP/zUWP72gvO/Qob0x5YR9hevFchGumXgQHvryCdplSMN08bv/lLt9AQZeKAmLoQzcX2XiNpEk09PDbeCKdzOkMbe6fnmmkf2kcx8SvDR/mnIc7vrccfjheYeWyqurC5ZnPVdOo9CxgZ8E4DIAZxDRO+7fuQCmAZhERI0AJrm/K0KYG2FJA49Zh6YP/2OjBvjW1FNdXprIo5mu9yFK+k3n64lfPgsAJh06GJedMNKX508uONx3jsxT4eqJo3Dsvvq2TF3BGSaIJx85VH1dyuVQ8enj9gnsq5IDRSplSFL28rwGSbqKa8ImyTS3OgJce/AvpOxJHsmBg3ri9IMH4fMf288fCE6nSFVoDDpeKC9DXScT0i2OHgVSf83rEppQeHp1qce23cFZfuLisA7+mZYAMH7/vXDny0swZp9+WNy0HYB5bGxKYtADODte9oO6SRnmLgxw1uFmAaL0/cArP5GnlklScnFmsS9dRcIf4wb9xSfR3NoOwECAh+QVp80O79sNH23eJaRjNiipUiqzJJu17tMmMBOTlN0Vb4JKGqvRz7puYmDf/P85K3QSDP9CTzx0MOb86Ez06dYJH65zBLhu44paUksX7/r4gzpCehnKq8G9u2LOj85E765mzVLbCyXlF4t3Z60mseOoJyi8V5VhCzKLfDzEBW93myPATYNvyXKiGFbwZ79zKsS5OQVD5Yc3V1aKfAhwAd4GrpqJGdeNkEemDUQNwoh4C76G2QxlpGUD9wZlenaJ96iD8TKylVj8Arm66D7puHUg4pm3enU1L2stkeRJeqZKWZ3GabOeCUU2uzkM6fsUI39ZaAJTjboag5i5EOCSWISRXijV9EyQwSRuV7/4xJG+lcR5ymEvk4ypO/G2rz/vUN/M0CTEaaPevR8+vDd+9amjjK+PGjDV1ZB+dP5h2H9gD/zq6Q+kx/9y5fGlONphDO/brVSnab2yD335RKzd2pxSanp4z/KJb5yMBau3Gl078ZDB+PakgzBFmKEZl9gmlFRyV6RtbAPPsDAKciHAA5D661iXcCp9Vsi6nLJBMYjnpdAorhCmC5uQylR6d/vJY/YOxJTQwWTANIw+3Trha2eMUgrwkw4MTsxS4dXpum3pCN1j9+2XSjomeL2pQ4f1xqGK6HwqCgXC1yfI16HUaTPie+sJcGMTiiSvtGKrxPZCqaDoyUk0wmCNRM7ErDEV3BtU1W1cKcpvH8eM6Ivh3CrikeVIIQCS6YtgTFX9wGvACB6XjIou1smAnl2Us0M9Pnmso8wcPjw6+FVYXqp9cTB1ACibcyrXIPOpgaMsSMRBzPLMwxoT4N7UY+0ZrNmU4+GvnBR9Ukg54rwc3jJVsghuaZBmJMc9iazaWCldd9sgcQYQmXzkUEw+MrhIx5F798GjXwuGpA0renqzmE3Pr/zHPCcaeHCfKu6Ap4HvY7iQQ9YUQ9yuZKjihleaNLxQvNC6OvblOFR1JqakPgb0zH418jTIqmVVtMlK8tp3L/ksaVNKPUfNrmM13tTcauDqcLIF3PlfY3Hk3mZdsUqh7wfuDmJWuYeepDv6/HdOw0ebd2HW0o0AzAX4v772MT17agpd1nuuGBd9kgSZm+a/vi5fxKAj8Px3TsMqwV9axGsz/btn9yETQ1Pw3P35cXh7+SZcdc/sRHmUJ/Jonl+Kz5QoWyNyLMCdrayuJh4aXPC32oQF/5FRmsiTUXl0EV8Qo9VPBvTAyAE9MGflZgBAS7tZyz5C8yOchm39wJgR7WQmsaF99McYqkkcP3DvmYaxaWcLAGB4v+T1ENXeZHcwsFcXnHlYCl5Xhjbw8upXlSMfJhTJDqIQCR6Bt6L7ZeP3jTgzPc4+zJkK7g3WRFGayFNlFfysFF6EzhITyrcnHYRDIkKWRnHSgXvh8hNHZraeKAB8TNMzhchZOV0+S7c2yapljR7SC7261ON7Z49WnhP2yC4/caR2Xlm+H2WvktodY8mFAJeR5Ll5K7pfe666gaXNiL26Y+m0ydLoaTJKXihVVsH36e+W241SF8dc4a1s0tLeXtr39Qmj8OTVJ6su0eIvV47Hj88/DGnoPKqe0b1XHh96HX/ZV08/EE9fc2rislSKrNpW3+6d8e5Pzor0PFHBB4eLam9Zvh7mboR2EFObssNO/Jc3zQo/cu++APRXe4+iPJGntoijjHgaeGtbNppMKgpSzIoudQQzVtJGZDAoX6sukPxreUjEvIEsZaapjKmGB1xubeBpdJ34WV//97njEtkub73kaHywdlusqeAyfMGsaoAkxSh5ociW8k6BanZwKyEEn/jGyRjapyuO/umMVNOtkaYVgK/Tn154uOKc7PFCJpiHk60cuRDgYR+0tD52px2cbEW4Hl3qA6uAJ6Ha7oMqYmng9Vm7ESZvBLEFcQUek+ksybzDN/2oqfVZfkDtVPqU+MIp+2Huys34win742+zVmCvnl2wbONOAMm/dt8/d3TNCkvA3yiumXgQunWurtUrjsnqjNGDcOIBe+E7nG0zTWohakIlmtBXTjsAg3t3Lf2+/bJj8fR7a2OnV81m/+1JB+Ffc1YFVoU3JeweLjpmeKJB+IKho4TX02wz9LZKQi4E+NA+3fDgl08EUPaKSKvtXXXKASmllC6yBR2uniiPPVEJTGMj8/ToUo/7vjA+5RKVScUEXuM2cAD4ruDVcdZhQxIJqGrawEcO6IGl04IzL4H0Piw3fnpMoutNF3TwIil6cV0qgc6San8monVENI/b15+IZhBRo7tNz3ZgSC27+CQhrYA8aVFjxfGRjgklnDH79I11XS1Tqx3PWhlcNfVC8dacbW6rnADX0cD/D8BvAdzN7ZsKYCZjbBoRTXV/fy/94qmp1caXFtWYFJBXUvEDD2lQb35/gjL2d60MMschquRvXT8pdBm0rKi1KtXWwF0BvqulhjRwxtiLADYKuy8AMN39fzqAC9Mtlj4dVcDVWiOutfLwZL2I7KDeXUsv555E/x6d0ad75Ret0Glqnmtqlh1wVbwlFd07OfqwtzhFJYhrAx/MGFsNAIyx1USkdOEgoqsAXAUAI0aMiJmdNGU4+aeYZA1RK91IkVqs73RmYmZ33U2fGYPuNfgBqNXeQ31dAd+cOApnHqq27z/45RPx5LzVmX5YTW3gXV0Hg901ZkJJBGPsDgB3AMDYsWNTe/1rtO2lRq3EQvGo5fpOx4SS3XUXHj08XuIZU8OPFN+ceFDo8YOH9NKe1RyXguHqXt4gZk2ZUBSsJaKhAOBu16VXJDNqUCFMhVrVjrI2V8QhSZkudldFMl3Ky6NWe0o61GgTqxlMF3Tw1sv91Fi9eEdpEFcDfxTAFADT3O0jqZVIE9v2KkstC6okGvi15x6CH59/WGwBnmdqVUmoFbza0fVCqSsQFv707JJ9vhLouBHeD+A1AAcT0UoiugKO4J5ERI0AJrm/q0MtGmVToNbcI/v1cGI71xdqL3xOkqqqL1Ai4W1lYMelZ5d6d6vfPrp2qiuZXipBpAbOGLtEcWhCymUxgvYQN7u4WtL0z48rNcA0uOkzY/CvOatwyNBs7Y5h3P35cdLBQFMTyl2fOw6fu2sWgNoNWWCpPh8/ahjWbWvGZeNHVrsoSnIxE1OGfe3COfWggamm179HZ0wxiNOcBaco7sl0Kv3pXNybpB2KGusoWVKkrkA1O1Pbo/b6w4Z01BfImzjy9TMOrHJJap8k5iargVvyTG4FeEd/7zrXF7B02mR87qRkwX72BJJ8w5MK8I7eDi21TW4FeA/XvptFoHtLvkjSC0s63uQJ8LhralosScitDfyAgT1x53+NxfgD9qp2USxVJokGntSVrkt9He7+/DgcPlxvAWaLJU1yK8CB2lx93lIFqjwQohpctViyJrcmFIvFI2z1c0uQaRcdgcP2sFV+OipWgFtyz4kHDsBNnxlT7WLkhovHjcDj3zi52sWwpIAV4JZE9KtCuFGLxeKQaxu4pfo8++3TsGlnS7WLYbHskVgBbklEvx6dS3FSLBZLZbEmFIvFYskpVoBbLBZLTrEC3CLlgIE9ql0EI7yZkMfvZyd2WfYcrA3cEuCdH07K3QIHhw/vg9evnYDBvbtUuygWS8VIpIET0dlE9D4RfUhEU9MqlKW69O3eOXcCHACG9OlqV5mx7FHE1sCJqA7A7+CsyLMSwCwiepQxNj+twlkcbrjoiMwXcN3TeOjLJ6Jx7bZqF8NiSUQSE8o4AB8yxhYDABH9FcAFAKwAT5lLxo2odhE6HMfu2w/H7tuv2sWwWBKRxIQyHMAK7vdKd58PIrqKiBqIqKGpqSlBdhaLxWLhSSLAZcbGQFg4xtgdjLGxjLGxAwfaqG0Wi8WSFkkE+EoA+3C/9wawKllxLBaLxaJLEgE+C8AoItqPiDoDuBjAo+kUy2KxWCxRxB7EZIy1EdHXAPwbQB2APzPG3kutZBaLxWIJJdFEHsbYEwCeSKksFovFYjHATqW3WCyWnGIFuMViseQUYhVcEJaImgAsi3n5AADrUyxOHrD3vGdg73nPIMk978sYC/hhV1SAJ4GIGhhjY6tdjkpi73nPwN7znkEW92xNKBaLxZJTrAC3WCyWnJInAX5HtQtQBew97xnYe94zSP2ec2MDt1gsFoufPGngFovFYuGwAtxisVhySi4EeEdcuo2I9iGi54hoARG9R0RXu/v7E9EMImp0t/24a6516+B9IjqreqVPBhHVEdHbRPSY+7tD3zMR9SWiB4loofu8T9gD7vkat13PI6L7iahrR7tnIvozEa0jonncPuN7JKJjiehd99gtZLIuIGOspv/gBMpaBGB/AJ0BzAFwaLXLlcJ9DQVwjPt/LwAfADgUwC8ATHX3TwXwv+7/h7r33gXAfm6d1FX7PmLe+7cA3AfgMfd3h75nANMBXOn+3xlA3458z3AWdlkCoJv7+wEAl3e0ewZwCoBjAMzj9hnfI4A3AZwAZ42FJwGco1uGPGjgpaXbGGMtALyl23INY2w1Y+wt9/9tABbAafgXwHnh4W4vdP+/AMBfGWO7GWNLAHwIp25yBRHtDWAygDu53R32nomoN5wX/U8AwBhrYYxtRge+Z5d6AN2IqB5AdzhrBXSoe2aMvQhgo7Db6B6JaCiA3oyx15gjze/mrokkDwJca+m2PENEIwEcDeANAIMZY6sBR8gDGOSe1lHq4SYA3wVQ5PZ15HveH0ATgLtcs9GdRNQDHfieGWMfAfgVgOUAVgPYwhh7Gh34njlM73G4+7+4X4s8CHCtpdvyChH1BPAQgG8yxraGnSrZl6t6IKLzAKxjjM3WvUSyL1f3DEcTPQbAbYyxowHsgNO1VpH7e3btvhfAMRUMA9CDiC4Nu0SyL1f3rIHqHhPdex4EeIdduo2IOsER3n9hjD3s7l7rdqvgbte5+ztCPZwE4HwiWgrHFHYGEd2Ljn3PKwGsZIy94f5+EI5A78j3PBHAEsZYE2OsFcDDAE5Ex75nD9N7XOn+L+7XIg8CvEMu3eaONP8JwALG2I3coUcBTHH/nwLgEW7/xUTUhYj2AzAKzuBHbmCMXcsY25sxNhLOc3yWMXYpOvY9rwGwgogOdndNADAfHfie4ZhOxhNRd7edT4AzxtOR79nD6B5dM8s2Ihrv1tV/cddEU+2RXM3R3nPheGksAvCDapcnpXv6GJyu0lwA77h/5wLYC8BMAI3utj93zQ/cOngfBiPVtfgH4DSUvVA69D0DGAOgwX3W/wTQbw+4558AWAhgHoB74HhfdKh7BnA/HBt/KxxN+oo49whgrFtPiwD8Fu4MeZ0/O5XeYrFYckoeTCgWi8VikWAFuMViseQUK8AtFoslp1gBbrFYLDnFCnCLxWLJKVaAWywWS06xAtxisVhyyv8Heh1gQUkq45AAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# load file\n",
+    "ages_population = pd.read_csv(\"/Users/rickardramhoj/ironhack_assignments/lab-understanding-descriptive-stats/data/ages_population.csv\", index_col=0)\n",
+    "\n",
+    "ages_population.reset_index(drop=False, inplace=True)\n",
+    "\n",
+    "# check out df\n",
+    "display(ages_population)\n",
+    "\n",
+    "# create plot\n",
+    "plt.plot(ages_population[\"observation\"])\n",
+    "\n",
+    "# show plot\n",
+    "plt.show()\n",
+    "\n",
+    "# guesses for mean and standard deviation\n",
+    "# mean = 35\n",
+    "# std = 10"
    ]
   },
   {
@@ -290,11 +675,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 75,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "observation    36.56\n",
+      "dtype: float64\n",
+      "observation    12.81009\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# mean\n",
+    "print(ages_population.mean())\n",
+    "\n",
+    "#std\n",
+    "print(np.std(ages_population))"
    ]
   },
   {
@@ -305,6 +707,8 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "# The guesses are similar to what the values are\n",
     "\"\"\""
    ]
   },
@@ -317,11 +721,132 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 76,
    "metadata": {},
-   "outputs": [],
+   "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>observation</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>25.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>31.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>29.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>31.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>29.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>995</th>\n",
+       "      <td>26.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>996</th>\n",
+       "      <td>22.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>997</th>\n",
+       "      <td>21.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>998</th>\n",
+       "      <td>19.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>999</th>\n",
+       "      <td>28.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1000 rows × 1 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     observation\n",
+       "0           25.0\n",
+       "1           31.0\n",
+       "2           29.0\n",
+       "3           31.0\n",
+       "4           29.0\n",
+       "..           ...\n",
+       "995         26.0\n",
+       "996         22.0\n",
+       "997         21.0\n",
+       "998         19.0\n",
+       "999         28.0\n",
+       "\n",
+       "[1000 rows x 1 columns]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "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": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# load file\n",
+    "ages_population2 = pd.read_csv(\"/Users/rickardramhoj/ironhack_assignments/lab-understanding-descriptive-stats/data/ages_population2.csv\", index_col=0)\n",
+    "\n",
+    "ages_population2.reset_index(drop=False, inplace=True)\n",
+    "\n",
+    "# check out df\n",
+    "display(ages_population2)\n",
+    "\n",
+    "# create plot\n",
+    "plt.plot(ages_population2[\"observation\"])\n",
+    "\n",
+    "# show plot\n",
+    "plt.show()\n"
    ]
   },
   {
@@ -339,6 +864,8 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "# the distribution is tighter around the mean. There is not as much variation. \n",
     "\"\"\""
    ]
   },
@@ -351,11 +878,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 78,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "observation    27.155\n",
+      "dtype: float64\n",
+      "observation    2.968329\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# mean\n",
+    "print(ages_population2.mean())\n",
+    "\n",
+    "#std\n",
+    "print(np.std(ages_population2))"
    ]
   },
   {
@@ -366,6 +910,8 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "# As predicted, the standard deviation is much lower\n",
     "\"\"\""
    ]
   },
@@ -381,11 +927,132 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 79,
    "metadata": {},
-   "outputs": [],
+   "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>observation</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>21.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>21.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>24.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>31.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>54.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>995</th>\n",
+       "      <td>16.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>996</th>\n",
+       "      <td>55.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>997</th>\n",
+       "      <td>30.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>998</th>\n",
+       "      <td>35.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>999</th>\n",
+       "      <td>43.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1000 rows × 1 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     observation\n",
+       "0           21.0\n",
+       "1           21.0\n",
+       "2           24.0\n",
+       "3           31.0\n",
+       "4           54.0\n",
+       "..           ...\n",
+       "995         16.0\n",
+       "996         55.0\n",
+       "997         30.0\n",
+       "998         35.0\n",
+       "999         43.0\n",
+       "\n",
+       "[1000 rows x 1 columns]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "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": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# load file\n",
+    "ages_population3 = pd.read_csv(\"/Users/rickardramhoj/ironhack_assignments/lab-understanding-descriptive-stats/data/ages_population3.csv\", index_col=0)\n",
+    "\n",
+    "ages_population3.reset_index(drop=False, inplace=True)\n",
+    "\n",
+    "# check out df\n",
+    "display(ages_population3)\n",
+    "\n",
+    "# create plot\n",
+    "plt.plot(ages_population3[\"observation\"])\n",
+    "\n",
+    "# show plot\n",
+    "plt.show()"
    ]
   },
   {
@@ -397,11 +1064,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 81,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "observation    41.989\n",
+      "dtype: float64\n",
+      "observation    16.136632\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# mean\n",
+    "print(ages_population3.mean())\n",
+    "\n",
+    "#std\n",
+    "print(np.std(ages_population3))"
    ]
   },
   {
@@ -412,6 +1096,8 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "# the standard deviation is higher and the mean is higher as well\n",
     "\"\"\""
    ]
   },
@@ -424,11 +1110,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 85,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "observation    30.0\n",
+      "Name: 0.25, dtype: float64\n",
+      "observation    40.0\n",
+      "Name: 0.5, dtype: float64\n",
+      "observation    53.0\n",
+      "Name: 0.75, dtype: float64\n",
+      "observation    41.989\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "#1st quartile \n",
+    "print(ages_population3.quantile(0.25))\n",
+    "\n",
+    "#2nd quartile \n",
+    "print(ages_population3.quantile(0.5))\n",
+    "\n",
+    "#3rd quartile \n",
+    "print(ages_population3.quantile(0.75))\n",
+    "\n",
+    "# mean\n",
+    "print(ages_population3.mean())"
    ]
   },
   {
@@ -439,6 +1152,9 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "# the median and the mean are close. The difference is 1.989. It is slightly skewed. \n",
+    "\n",
     "\"\"\""
    ]
   },
@@ -451,11 +1167,54 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 89,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "observation    1.0\n",
+      "dtype: float64\n",
+      "observation    22.0\n",
+      "Name: 0.1, dtype: float64\n",
+      "observation    67.0\n",
+      "Name: 0.9, dtype: float64\n",
+      "observation    77.0\n",
+      "dtype: float64\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": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# min\n",
+    "print(ages_population3.min())\n",
+    "\n",
+    "# 10 % quantile\n",
+    "print(ages_population3.quantile(0.10))\n",
+    "\n",
+    "# 90 % quantile\n",
+    "print(ages_population3.quantile(0.90))\n",
+    "\n",
+    "# max\n",
+    "print(ages_population3.max())\n",
+    "\n",
+    "ages_population3.hist()\n",
+    "\n",
+    "plt.show()"
    ]
   },
   {
@@ -466,6 +1225,8 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "The dataset is positively skewed, which also can be seen in a histogram. \n",
     "\"\"\""
    ]
   },
@@ -500,9 +1261,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "ironhack-3.7",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "ironhack-3.7"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -514,7 +1275,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.7.10"
   }
  },
  "nbformat": 4,