From d854860d6c11afaae105754d92556802bc1ef76a Mon Sep 17 00:00:00 2001
From: vierpie <pieter.vierstraete@outlook.be>
Date: Tue, 28 Jul 2020 19:05:27 +0200
Subject: [PATCH] my answers

---
 your-code/main.ipynb | 1121 +++++++++++++++++++++++++++++++++++++++---
 1 file changed, 1058 insertions(+), 63 deletions(-)

diff --git a/your-code/main.ipynb b/your-code/main.ipynb
index a0a5b66..d608f09 100644
--- a/your-code/main.ipynb
+++ b/your-code/main.ipynb
@@ -11,11 +11,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 285,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Libraries"
+    "# Libraries\n",
+    "\n",
+    "import pandas as pd\n",
+    "import random\n",
+    "import matplotlib.pyplot as plt\n",
+    "import math"
    ]
   },
   {
@@ -29,11 +34,126 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 80,
    "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>dice rolls</th>\n",
+       "      <th>Throw nr.</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>5</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>4</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>3</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>5</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>6</td>\n",
+       "      <td>7</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>3</td>\n",
+       "      <td>8</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>5</td>\n",
+       "      <td>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>5</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   dice rolls  Throw nr.\n",
+       "0           5          1\n",
+       "1           6          2\n",
+       "2           4          3\n",
+       "3           2          4\n",
+       "4           3          5\n",
+       "5           5          6\n",
+       "6           6          7\n",
+       "7           3          8\n",
+       "8           5          9\n",
+       "9           5         10"
+      ]
+     },
+     "execution_count": 80,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "# new list to store the dice rolls\n",
+    "\n",
+    "min_value = 1\n",
+    "max_value = 6\n",
+    "\n",
+    "\n",
+    "dice_rolls =[random.randint(min_value,max_value) for i in range(1,11)]\n",
+    "\n",
+    "# dataframe from the list\n",
+    "df_dice = pd.DataFrame(dice_rolls,columns = ['dice rolls'])\n",
+    "\n",
+    "# add the column with the throw numbers\n",
+    "throw = [i for i in range(1,11)]\n",
+    "throw\n",
+    "df_dice['Throw nr.'] = throw\n",
+    "df_dice"
    ]
   },
   {
@@ -45,11 +165,75 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 64,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[RangeIndex(start=0, stop=10, step=1)]"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "lst = [df_dice.index]\n",
+    "lst"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# your code here\n",
+    "\n",
+    "\n",
+    "df_dice = df_dice.sort_values(by='dice rolls', ascending = True)\n",
+    "\n",
+    "plt.scatter(x=df_dice['dice rolls'], y=df_dice.index)\n",
+    "\n",
+    "plt.xlabel(\"number of dice roll\")\n",
+    "plt.ylabel(\"value dice roll\")\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 158,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Int64Index([3, 4, 7, 2, 0, 5, 8, 9, 1, 6], dtype='int64')"
+      ]
+     },
+     "execution_count": 158,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_dice.index"
    ]
   },
   {
@@ -61,11 +245,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 136,
    "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",
+    "y1 = df_dice['dice rolls'].value_counts()\n",
+    "y1.dtype\n",
+    "\n",
+    "# histogram\n",
+    "df_dice['dice rolls'].value_counts().plot.bar()\n",
+    "\n",
+    "\n",
+    "plt.show()\n"
    ]
   },
   {
@@ -76,6 +282,12 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "The frequency distribution tells how frequency of occurences is distributed over the possible values of the dice toss.\n",
+    "\n",
+    "The histogram is much more intuitive and easy to read compared to the plot of the unique values of the dice.\n",
+    "The frequency distribution should be the same over all the 6 possible tosses and equal to the total number of dice tosses divided by 6\n",
+    "\n",
     "\"\"\""
    ]
   },
@@ -91,11 +303,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 96,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4.4"
+      ]
+     },
+     "execution_count": 96,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "mean_calculated = df_dice['dice rolls'].sum()/len(df_dice)\n",
+    "mean_calculated"
    ]
   },
   {
@@ -107,11 +333,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 183,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4.4"
+      ]
+     },
+     "execution_count": 183,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# create the dataframe with the value counts\n",
+    "y1 = df_dice['dice rolls'].value_counts()\n",
+    "\n",
+    "# creating the list with the number of throws and the values from the dataframe y1\n",
+    "thr = list(y1.values)\n",
+    "val = list(y1.index)\n",
+    "\n",
+    "# creating the list with the calculation of the frequency distribution\n",
+    "freq_distr = [i*j for i,j in zip(thr,val) ]\n",
+    "\n",
+    "# calculating the mean value\n",
+    "sum(freq_distr/sum(thr))\n",
+    "\n"
    ]
   },
   {
@@ -124,11 +375,74 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 199,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5    4\n",
+       "6    2\n",
+       "3    2\n",
+       "4    1\n",
+       "2    1\n",
+       "Name: dice rolls, dtype: int64"
+      ]
+     },
+     "execution_count": 199,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 300,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "# the median is the middle number in an odd list of elements, and the average of the two middle elements in an even list of elements\n",
+    "\n",
+    "def median(y1):\n",
+    "\n",
+    "# defining the slicing operators\n",
+    "    a = int(len(y1)/2)\n",
+    "    b = int((len(y1)-1)/2)\n",
+    "\n",
+    "# defining the lists to work on\n",
+    "    thr = list(y1.values)\n",
+    "    val = list(y1.index)\n",
+    "\n",
+    "# defining the condition to return the median \n",
+    "    if len(y1)%2==0:\n",
+    "        median = (thr[math.floor(a)]+thr[math.ceil(a)])/2\n",
+    "    else:\n",
+    "        median = thr[b]\n",
+    "    return median"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 301,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "32.0"
+      ]
+     },
+     "execution_count": 301,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "median(y1)"
    ]
   },
   {
@@ -140,11 +454,70 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 293,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "def quartiles(y1):\n",
+    "\n",
+    "# defining the slicing operators\n",
+    "    q1 = int(len(y1)/4)\n",
+    "    q1_odd = int((len(y1)-1)/4)\n",
+    "    \n",
+    "# defining the lists to work on\n",
+    "    thr = list(y1.values)\n",
+    "    val = list(y1.index)\n",
+    "\n",
+    "# defining the condition to return the lower quartile \n",
+    "    if len(y1)%2==0:\n",
+    "        upper_quartile = (thr[math.floor(q1)]+thr[math.ceil(q1)])/2\n",
+    "        lower_quartile = (thr[3*math.floor(q1)]+thr[(3*math.floor(q1))])/2\n",
+    "    else:\n",
+    "        upper_quartile = thr[q1_odd]\n",
+    "        lower_quartile = thr[3*q1_odd]\n",
+    "    return (lower_quartile,upper_quartile)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 294,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(30.0, 39.0)"
+      ]
+     },
+     "execution_count": 294,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "quartiles(y1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 287,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 287,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "math.floor(3/2)"
    ]
   },
   {
@@ -158,11 +531,180 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 142,
    "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",
+    "roll_the_dice = pd.read_csv('/Users/pietervierstraete/Desktop/Ironhack/week5/lab-understanding-descriptive-stats/data/roll_the_dice_hundred.csv'\n",
+    "                    )\n",
+    "roll_the_dice['value'].value_counts().plot.bar()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 212,
+   "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>Unnamed: 0</th>\n",
+       "      <th>roll</th>\n",
+       "      <th>value</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>3</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>4</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95</th>\n",
+       "      <td>95</td>\n",
+       "      <td>95</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>96</th>\n",
+       "      <td>96</td>\n",
+       "      <td>96</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>97</th>\n",
+       "      <td>97</td>\n",
+       "      <td>97</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>98</th>\n",
+       "      <td>98</td>\n",
+       "      <td>98</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>99</th>\n",
+       "      <td>99</td>\n",
+       "      <td>99</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>100 rows × 3 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    Unnamed: 0  roll  value\n",
+       "0            0     0      1\n",
+       "1            1     1      2\n",
+       "2            2     2      6\n",
+       "3            3     3      1\n",
+       "4            4     4      6\n",
+       "..         ...   ...    ...\n",
+       "95          95    95      4\n",
+       "96          96    96      6\n",
+       "97          97    97      1\n",
+       "98          98    98      3\n",
+       "99          99    99      6\n",
+       "\n",
+       "[100 rows x 3 columns]"
+      ]
+     },
+     "execution_count": 212,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "roll_the_dice"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 141,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6    23\n",
+      "4    22\n",
+      "2    17\n",
+      "3    14\n",
+      "5    12\n",
+      "1    12\n",
+      "Name: value, dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(roll_the_dice['value'].value_counts())"
    ]
   },
   {
@@ -173,6 +715,9 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "the number of occurences of the 6 possible values are comprised between 12 and 23 occurences\n",
+    "Intuitively I would have expected a similar point mass function for the 6 different throws\n",
     "\"\"\""
    ]
   },
@@ -185,11 +730,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 213,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3.74"
+      ]
+     },
+     "execution_count": 213,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "\n",
+    "mean_calculated = roll_the_dice['value'].sum()/len(roll_the_dice)\n",
+    "mean_calculated"
    ]
   },
   {
@@ -201,11 +761,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 214,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[138, 88, 34, 42, 60, 12]"
+      ]
+     },
+     "execution_count": 214,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# create the dataframe with the value counts\n",
+    "y1 = roll_the_dice['value'].value_counts()\n",
+    "\n",
+    "# creating the list with the number of throws and the values from the dataframe y1\n",
+    "thr = list(y1.values)\n",
+    "val = list(y1.index)\n",
+    "\n",
+    "# creating the list with the calculation of the frequency distribution\n",
+    "freq_distr = [i*j for i,j in zip(thr,val)]\n",
+    "freq_distr"
    ]
   },
   {
@@ -217,11 +799,122 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 226,
    "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",
+    "#plt.hist(freq_distr,density=1) \n",
+    "#plot.axis([50, 110, 0, 0.06]) \n",
+    "#axis([xmin,xmax,ymin,ymax])\n",
+    "freq_val = pd.DataFrame(freq_distr)\n",
+    "freq_val['values dice'] = val\n",
+    "\n",
+    "# histogram\n",
+    "roll_the_dice['value'].value_counts().plot.bar()\n",
+    "plt.xlabel('Values dice')\n",
+    "plt.ylabel('number of occurences')\n",
+    "\n",
+    "plt.show()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 229,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>0</th>\n",
+       "      <th>values dice</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>138</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>88</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>34</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>42</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>60</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>12</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     0  values dice\n",
+       "0  138            6\n",
+       "1   88            4\n",
+       "2   34            2\n",
+       "3   42            3\n",
+       "4   60            5\n",
+       "5   12            1"
+      ]
+     },
+     "execution_count": 229,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "freq_val\n"
    ]
   },
   {
@@ -232,6 +925,12 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "##---------How can you connect the mean value to the histogram?-----------##\n",
+    "#The mean value is equal to the sumproduct of the values of the throws by the number of throws divided by the total amount of throws\n",
+    "\n",
+    "\n",
+    "\n",
     "\"\"\""
    ]
   },
@@ -244,11 +943,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 231,
    "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",
+    "roll_the_thousand = pd.read_csv('/Users/pietervierstraete/Desktop/Ironhack/week5/lab-understanding-descriptive-stats/data/roll_the_dice_thousand.csv'\n",
+    "                    )\n",
+    "roll_the_thousand['value'].value_counts().plot.bar()\n",
+    "plt.show()"
    ]
   },
   {
@@ -259,6 +976,10 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "The distribution of the number of throws per value of the dice is almost the same over the whole range.\n",
+    "This is conform to the idea that the more we repeat the experience of throwing the dice the closer who will come to the probabilistic calculation of dice throws.\n",
+    "In other words we approach for each value, the probability of occurence of each event as equal to 1/6\n",
     "\"\"\""
    ]
   },
@@ -274,11 +995,130 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 250,
    "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",
+       "  </tbody>\n",
+       "</table>\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"
+      ]
+     },
+     "execution_count": 250,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "address = '/Users/pietervierstraete/Desktop/Ironhack/week5/lab-understanding-descriptive-stats/data/ages_population'\n",
+    "population = pd.read_csv('/Users/pietervierstraete/Desktop/Ironhack/week5/lab-understanding-descriptive-stats/data/ages_population.csv')\n",
+    "population2 = pd.read_csv('/Users/pietervierstraete/Desktop/Ironhack/week5/lab-understanding-descriptive-stats/data/ages_population2.csv')\n",
+    "population3 = pd.read_csv('/Users/pietervierstraete/Desktop/Ironhack/week5/lab-understanding-descriptive-stats/data/ages_population3.csv')\n",
+    "                    \n",
+    "population.head()\n",
+    "population2.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 247,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1000, 1)"
+      ]
+     },
+     "execution_count": 247,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "population.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 252,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.hist(population['observation'])\n",
+    "plt.xlabel('Age')\n",
+    "plt.ylabel('number of occurences')\n",
+    "plt.show()\n",
+    "\n",
+    "# from the plotted frequency distribution the mean should be around 38y old and the standard deviation should be equal to 13y more or less"
    ]
   },
   {
@@ -290,11 +1130,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 255,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "observation    36.56\n",
+      "dtype: float64\n",
+      "observation    12.8165\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "# mean\n",
+    "print(population.mean())\n",
+    "\n",
+    "# standard deviation\n",
+    "print(population.std())\n",
+    "\n"
    ]
   },
   {
@@ -305,6 +1162,9 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "# my guess was not too far from the actual values\n",
+    "\n",
     "\"\"\""
    ]
   },
@@ -317,11 +1177,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 256,
    "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",
+    "plt.hist(population2['observation'])\n",
+    "plt.xlabel('Age')\n",
+    "plt.ylabel('number of occurences')\n",
+    "plt.show()"
    ]
   },
   {
@@ -339,6 +1217,10 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "The freuency distribution hhistogram is quite differen. There is a high concentration of ages between 25 and 30y old.\n",
+    "This neighbourhood seems to have a younger population profile\n",
+    "\n",
     "\"\"\""
    ]
   },
@@ -351,11 +1233,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 258,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "observation    27.155\n",
+      "dtype: float64\n",
+      "observation    2.969814\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# mean\n",
+    "print(population2.mean())\n",
+    "\n",
+    "# standard deviation\n",
+    "print(population2.std())\n",
+    "\n"
    ]
   },
   {
@@ -366,6 +1266,10 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "The mean age is lower than for the dataset population.\n",
+    "The standard deviation is only 2.97y, this translates in the fact that the population pyramid is much more concentrated around the average\n",
+    "\n",
     "\"\"\""
    ]
   },
@@ -381,11 +1285,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 259,
    "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",
+    "plt.hist(population3['observation'])\n",
+    "plt.xlabel('Age')\n",
+    "plt.ylabel('number of occurences')\n",
+    "plt.show()"
    ]
   },
   {
@@ -397,11 +1319,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 299,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "observation    41.989\n",
+      "dtype: float64\n",
+      "observation    16.144706\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# mean\n",
+    "print(population3.mean())\n",
+    "\n",
+    "# standard deviation\n",
+    "print(population3.std())"
    ]
   },
   {
@@ -412,6 +1351,11 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "The mean of the population is equal to 41.9 years\n",
+    "The standard deviation is 16.1 years.\n",
+    "\n",
+    "The standard deviation is much higher than for population 2 because the peak between 60 and 70 years old (which is at 20y from the mean) needs to be accounted for in the standard deviation and increases its value\n",
     "\"\"\""
    ]
   },
@@ -424,11 +1368,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 302,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(30.0, 39.0)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "32.0"
+      ]
+     },
+     "execution_count": 302,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "# your code here"
+    "# your code here\n",
+    "\n",
+    "# the following code gives the 25% and 75% quartile\n",
+    "population3_list = population3['observation']\n",
+    "population3_list\n",
+    "\n",
+    "print(quartiles(population3_list))\n",
+    "\n",
+    "# the following code gives the 50% median value\n",
+    "median(population3_list)\n"
    ]
   },
   {
@@ -439,6 +1410,9 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "We have Q1 = 30, Q2 =32 and Q3 = 39  \n",
+    "The interquartile range Q2-Q1 thus contains 25% of the values within a 2 year range but the mean is equal to 41 because of the peak between 60 and 70 years\n",
     "\"\"\""
    ]
   },
@@ -451,11 +1425,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 297,
    "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",
+    "\n",
+    "#the boxplot helps giving a visual of the percentiles\n",
+    "\n",
+    "plt.boxplot(population3_list) \n",
+    "plt.show()"
    ]
   },
   {
@@ -466,6 +1459,8 @@
    "source": [
     "\"\"\"\n",
     "your comments here\n",
+    "\n",
+    "50% of the values are concentrated between 30 and 39years old, but the higher values between 60 and 70y old have a big influence on the distribution\n",
     "\"\"\""
    ]
   },
@@ -500,9 +1495,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 +1509,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.7.6"
   }
  },
  "nbformat": 4,