From 7f86d339622a5b5a7fd6690c6f707ccfce8470c6 Mon Sep 17 00:00:00 2001 From: Giorgio Giao Date: Sat, 28 May 2022 15:21:05 +0100 Subject: [PATCH] Lab completed --- your-code/main.ipynb | 700 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 635 insertions(+), 65 deletions(-) diff --git a/your-code/main.ipynb b/your-code/main.ipynb index a0a5b66..27da636 100644 --- a/your-code/main.ipynb +++ b/your-code/main.ipynb @@ -11,11 +11,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "metadata": {}, "outputs": [], "source": [ - "# Libraries" + "# Libraries\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd" ] }, { @@ -29,11 +32,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 4, 2, 6, 3, 1, 2, 4, 6, 6])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "dice = np.random.randint(1,7,size=10)\n", + "dice" ] }, { @@ -45,11 +61,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 1 2 2 3 4 4 6 6 6]\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "dice.sort()\n", + "print(dice)\n", + "plt.plot(dice)" ] }, { @@ -61,11 +110,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(array([2., 2., 1., 2., 0., 3.]),\n", + " array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5]),\n", + " )" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "plt.hist(dice, bins =6 ,range=(0.5,6.5))" ] }, { @@ -76,6 +151,8 @@ "source": [ "\"\"\"\n", "your comments here\n", + "In the second plot we can se the amount of times we rolled each face of the dice. \n", + "The first plot the dice face is in the y axis and we have a plot with the coordinates of each roll connect by a line\n", "\"\"\"" ] }, @@ -91,11 +168,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.5\n" + ] + }, + { + "data": { + "text/plain": [ + "3.5" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "def average(result):\n", + " return sum(result)/len(result)\n", + "\n", + "print(average(dice))\n", + "\n", + "np.mean(dice)" ] }, { @@ -107,11 +208,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 76, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "3.5" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "def freq_dist(result):\n", + " my_dict={}\n", + " for face in result:\n", + " if face in my_dict:\n", + " my_dict[face] += 1\n", + " else:\n", + " my_dict[face] = 1\n", + " return my_dict\n", + "dist = freq_dist(dice)\n", + "sum([k*v for k, v in dist.items()])/len(dice)" ] }, { @@ -124,11 +246,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 81, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "3.5" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "def median(result):\n", + " if len(result)%2 == 0:\n", + " return (result[int((len(result)/2)-1)]+result[int((len(result)/2))])/2\n", + " else:\n", + " return result[int(len(result)/2)]\n", + "median(dice)" ] }, { @@ -140,11 +279,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 3.5, 6)" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "def quartiles(result):\n", + " \n", + " half = median(result)\n", + " \n", + " if len(result) % 2 == 0:\n", + " first = median(result[:int(len(result)/2)])\n", + " third= median(result[int(len(result)/2):])\n", + " \n", + " else:\n", + " first = median(vals[:int(len(result)/2)-1])\n", + " third = median(vals[int(len(result)/2)+1:])\n", + " \n", + " return first, half, third\n", + "quartiles(dice)" ] }, { @@ -158,11 +322,168 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 85, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0rollvalue
0001
1112
2226
3331
4446
............
9595954
9696966
9797971
9898983
9999996
\n", + "

100 rows × 3 columns

\n", + "
" + ], + "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": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "df_dice = pd.read_csv('/Users/giorgiogiao/Desktop/LABS_IRONHACK/lab-understanding-descriptive-stats/data/roll_the_dice_hundred.csv')\n", + "df_dice" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([12., 17., 14., 22., 12., 23.]),\n", + " array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5]),\n", + " )" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dice_1 = sorted(df_dice['value'])\n", + "plt.hist(dice_1, bins=6, range= (0.5, 6.5))" ] }, { @@ -173,6 +494,7 @@ "source": [ "\"\"\"\n", "your comments here\n", + "Three faces were rolled between 10-15 time while 3 faces were rolled more than 15 times.\n", "\"\"\"" ] }, @@ -185,11 +507,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 88, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "3.74" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "average(dice_1)" ] }, { @@ -201,11 +535,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 89, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{1: 12, 2: 17, 3: 14, 4: 22, 5: 12, 6: 23}" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "freq_dist(dice_1)" ] }, { @@ -217,11 +563,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 90, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(array([12., 17., 14., 22., 12., 23.]),\n", + " array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5]),\n", + " )" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "plt.hist(dice_1, bins=6, range= (0.5, 6.5))" ] }, { @@ -232,6 +604,8 @@ "source": [ "\"\"\"\n", "your comments here\n", + "if we had the same number of rolls for each face the we would have a mean of 3.5 \n", + "but as we can see in the plot we have more rolls of the higher faces so it increases the mean\n", "\"\"\"" ] }, @@ -244,11 +618,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 94, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(array([175., 167., 175., 168., 149., 166.]),\n", + " array([0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5]),\n", + " )" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "df_dicet = pd.read_csv('/Users/giorgiogiao/Desktop/LABS_IRONHACK/lab-understanding-descriptive-stats/data/roll_the_dice_thousand.csv')\n", + "dice_2 = sorted(df_dicet['value'])\n", + "plt.hist(dice_2, bins=6, range= (0.5, 6.5))" ] }, { @@ -259,6 +661,9 @@ "source": [ "\"\"\"\n", "your comments here\n", + "Yes, the amount of times that it face was rolled is much more similar. \n", + "This hapens becase we have the same chance to roll each face and the more we roll, \n", + "the more the frequency dist will tend to be the same between faces\n", "\"\"\"" ] }, @@ -274,11 +679,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 99, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[]], dtype=object)" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "df_ages = pd.read_csv('/Users/giorgiogiao/Desktop/LABS_IRONHACK/lab-understanding-descriptive-stats/data/ages_population.csv')\n", + "df_ages.hist()\n", + "# the mean will be between 32 to 42\n", + "# std should be around 10 to 15 y" ] }, { @@ -290,11 +722,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 101, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "36.56\n", + "12.816499625976762\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "print(df_ages.observation.mean())\n", + "print(df_ages.observation.std())" ] }, { @@ -305,6 +748,9 @@ "source": [ "\"\"\"\n", "your comments here\n", + "yes they did, for the mean as the distribution looks similar to a normal distribution \n", + "I just tookm the value of the bar with the most observations\n", + "for the STD I use the rue of 60% of the data should be in the the range of 1 std away of the mean.\n", "\"\"\"" ] }, @@ -317,11 +763,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 102, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[]], dtype=object)" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "df_ages2 = pd.read_csv('/Users/giorgiogiao/Desktop/LABS_IRONHACK/lab-understanding-descriptive-stats/data/ages_population2.csv')\n", + "df_ages2.hist()" ] }, { @@ -339,6 +810,8 @@ "source": [ "\"\"\"\n", "your comments here\n", + "Yes here we two bars in the middle that have much more obsevations than all the others \n", + "and we have a smaller total range of ages\n", "\"\"\"" ] }, @@ -351,11 +824,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 103, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27.155\n", + "2.969813932689186\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "print(df_ages2.observation.mean())\n", + "print(df_ages2.observation.std())" ] }, { @@ -366,6 +850,8 @@ "source": [ "\"\"\"\n", "your comments here\n", + "As mentioned before most of our observations fall into the middle ranges (26-28y) \n", + "thats why we have a much smaller std\n", "\"\"\"" ] }, @@ -381,11 +867,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 105, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[]], dtype=object)" + ] + }, + "execution_count": 105, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "df_ages3 = pd.read_csv('/Users/giorgiogiao/Desktop/LABS_IRONHACK/lab-understanding-descriptive-stats/data/ages_population3.csv')\n", + "df_ages3.hist()" ] }, { @@ -397,11 +908,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 106, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "41.989\n", + "16.144705959865934\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "print(df_ages3.observation.mean())\n", + "print(df_ages3.observation.std())" ] }, { @@ -412,6 +934,9 @@ "source": [ "\"\"\"\n", "your comments here\n", + "Here we have high obsevation to the right of the plot which is bringing the mean to a higher value.\n", + "Also as we don´t have the peak in the middle or a normal distribtion \n", + "it has a higher std(the observations are more spread)\n", "\"\"\"" ] }, @@ -424,11 +949,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 113, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "30.0\n", + "40.0\n", + "53.0\n" + ] + }, + { + "data": { + "text/plain": [ + "0.2103888369644793" + ] + }, + "execution_count": 113, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "# your code here\n", + "print(df_ages3.observation.quantile(.25))\n", + "print(df_ages3.observation.quantile(.5))\n", + "print(df_ages3.observation.quantile(.75))\n", + "df_ages3.observation.skew()" ] }, { @@ -439,6 +988,8 @@ "source": [ "\"\"\"\n", "your comments here\n", + "The mean and median are similar around 2y difference \n", + "the mean is higher because than median because our distribution is positively skewed\n", "\"\"\"" ] }, @@ -451,11 +1002,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 115, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "50.0\n", + "53.0\n", + "57.0\n", + "64.0\n", + "67.0\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "\n", + "print(df_ages3.observation.quantile(.70))\n", + "print(df_ages3.observation.quantile(.75))\n", + "print(df_ages3.observation.quantile(.80))\n", + "print(df_ages3.observation.quantile(.85))\n", + "print(df_ages3.observation.quantile(.90))" ] }, { @@ -466,6 +1035,7 @@ "source": [ "\"\"\"\n", "your comments here\n", + "we have a jump when looking into the percentil85 where we have an intermediate peak\n", "\"\"\"" ] }, @@ -500,9 +1070,9 @@ ], "metadata": { "kernelspec": { - "display_name": "ironhack-3.7", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "ironhack-3.7" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -514,7 +1084,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.9.7" } }, "nbformat": 4,