diff --git a/your-code/lab-understanding-descriptive-stats_joaopq.ipynb b/your-code/lab-understanding-descriptive-stats_joaopq.ipynb new file mode 100644 index 0000000..d121e2c --- /dev/null +++ b/your-code/lab-understanding-descriptive-stats_joaopq.ipynb @@ -0,0 +1,1550 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Understanding Descriptive Statistics\n", + "\n", + "Import the necessary libraries here:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Bad key \"text.kerning_factor\" on line 4 in\n", + "C:\\Users\\joaop\\anaconda3\\lib\\site-packages\\matplotlib\\mpl-data\\stylelib\\_classic_test_patch.mplstyle.\n", + "You probably need to get an updated matplotlibrc file from\n", + "https://github.com/matplotlib/matplotlib/blob/v3.1.3/matplotlibrc.template\n", + "or from the matplotlib source distribution\n" + ] + } + ], + "source": [ + "# Libraries\n", + "import pandas as pd \n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy\n", + "import math\n", + "import random" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 1\n", + "#### 1.- Define a function that simulates rolling a dice 10 times. Save the information in a dataframe.\n", + "**Hint**: you can use the *choices* function from module *random* to help you with the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here\n", + "list_x=[]\n", + "\n", + "def roll_dice():\n", + " sequence=[1,2,3,4,5,6]\n", + " random.choice(sequence)\n", + " list_x=[random.choice(sequence) for x in range(1,11)] #creating list to randomly select\n", + " df=pd.DataFrame(list_x)\n", + " return df\n", + "df=roll_dice()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "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", + "
0
05
12
21
35
41
52
65
72
86
96
\n", + "
" + ], + "text/plain": [ + " 0\n", + "0 5\n", + "1 2\n", + "2 1\n", + "3 5\n", + "4 1\n", + "5 2\n", + "6 5\n", + "7 2\n", + "8 6\n", + "9 6" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df #printing df " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Plot the results sorted by value." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "df.sort_values(by=0)\n", + "df[0].plot.bar()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Calculate the frequency distribution and plot it. What is the relation between this plot and the plot above? Describe it with words." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "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\n", + "df[0].plot.hist()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\nWe can see that the plot above shows the number of occurrences.\\nThe first plot shows in each dice throw what is the value of the dice. It doesn't retrieve the absolute frequency of analyzed data.\\n\"" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "We can see that the plot above shows the number of occurrences.\n", + "The first plot shows in each dice throw what is the value of the dice. It doesn't retrieve the absolute frequency of analyzed data.\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 2\n", + "Now, using the dice results obtained in *challenge 1*, your are going to define some functions that will help you calculate the mean of your data in two different ways, the median and the four quartiles. \n", + "\n", + "#### 1.- Define a function that computes the mean by summing all the observations and dividing by the total number of observations. You are not allowed to use any methods or functions that directly calculate the mean value. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 3.5\n", + "dtype: float64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "\n", + "def mean_(x): #defining func\n", + " '''\n", + " below we have the sum of the values of the dice throws and below (divisor) the count of dice throws (10) \n", + " '''\n", + " return x.sum()/x.count()\n", + "\n", + "mean_(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- First, calculate the frequency distribution. Then, calculate the mean using the values of the frequency distribution you've just computed. You are not allowed to use any methods or functions that directly calculate the mean value. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 3.5\n", + "dtype: float64" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "\n", + "'''\n", + "my approach:\n", + "create dict in which...\n", + "_keys=set of values of the dice throws (can be from 1 to 6, as we know)\n", + "_values=freq of the keys\n", + "'''\n", + "\n", + "freq_distrib=dict() #instantiate dict.\n", + "\n", + "for x in set(df[0]):\n", + " freq_distrib[x]=list(df[0]).count(x)/df.count() #create freq ratio for each key here.\n", + " \n", + "#mean will be equal to keys*values\n", + "sum( [ freq_distrib[x]*x for x in freq_distrib ] ) #multiplying all then summing afterwards the elements of the list." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Define a function to calculate the median. You are not allowed to use any methods or functions that directly calculate the median value. \n", + "**Hint**: you might need to define two computation cases depending on the number of observations used to calculate the median." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "[1, 1, 2, 2, 2, 5, 5, 5, 6, 6]\n" + ] + }, + { + "data": { + "text/plain": [ + "3.5" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "import math\n", + "\n", + "def median_(x):\n", + " '''\n", + " median is computed differently depending on the cardinality of the dataframe.\n", + " we can use a logical gateway to differ these calculus.\n", + " '''\n", + " index=int(len(x)/2)\n", + " print(index)\n", + " \n", + " x=sorted(list(x))\n", + " print(x)\n", + " \n", + " if len(x)%2==0: #if cardinality is even, then it's calculated as it can be seen below.\n", + " first_middle_number=x[index]\n", + " second_middle_number=x[index-1]\n", + " final_median=(first_middle_number+second_middle_number)/2\n", + " return final_median\n", + " \n", + " elif len(x)%2!=0: #if cardinality is odd, then it's calculated as it can be seen below.\n", + " index=round(int(len(x)/2))\n", + " final_median=x[int(len(x)/2)]\n", + " return final_median\n", + " else:\n", + " pass \n", + " \n", + "median_(df[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- Define a function to calculate the four quartiles. You can use the function you defined above to compute the median but you are not allowed to use any methods or functions that directly calculate the quartiles. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "[1, 1, 2, 2, 2, 5, 5, 5, 6, 6]\n" + ] + }, + { + "data": { + "text/plain": [ + "'Quartiles are, respectively: Q1=2, Q2=3.5, and Q3=5.\\n Additionally, the interquartile range is 3.'" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "def four_quartiles_of_the_apocalypse(x):\n", + " '''\n", + " first things first: we have to sort the inputted column of the df\n", + " '''\n", + " x=sorted(list(x))\n", + " \n", + " index=len(x)-1\n", + " \n", + " #q1 can be computed like below. \n", + " index_q1=int(index*0.25)\n", + " q1=x[index_q1]\n", + " \n", + " #q2 can be computed like below. \n", + " q2=median_(x)\n", + " \n", + " #q3 can be computed like below. \n", + " index_q3=int(index*0.75)\n", + " q3=x[index_q3]\n", + " \n", + " #bonus:\n", + " interquartile_range=q3-q1\n", + " \n", + " return f'''Quartiles are, respectively: Q1={q1}, Q2={q2}, and Q3={q3}.\n", + " Additionally, the interquartile range is {interquartile_range}.'''\n", + "\n", + "four_quartiles_of_the_apocalypse(df[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 3\n", + "Read the csv `roll_the_dice_hundred.csv` from the `data` folder.\n", + "#### 1.- Sort the values and plot them. What do you see?" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "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", + "
Unnamed: 0rollvalue
count100.000000100.000000100.000000
mean49.50000049.5000003.740000
std29.01149229.0114921.703354
min0.0000000.0000001.000000
25%24.75000024.7500002.000000
50%49.50000049.5000004.000000
75%74.25000074.2500005.000000
max99.00000099.0000006.000000
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 roll value\n", + "count 100.000000 100.000000 100.000000\n", + "mean 49.500000 49.500000 3.740000\n", + "std 29.011492 29.011492 1.703354\n", + "min 0.000000 0.000000 1.000000\n", + "25% 24.750000 24.750000 2.000000\n", + "50% 49.500000 49.500000 4.000000\n", + "75% 74.250000 74.250000 5.000000\n", + "max 99.000000 99.000000 6.000000" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "df=pd.read_csv(\"roll_the_dice_hundred.csv\")\n", + "df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\nI see the dice was thrown 100x.\\nThe mean of these 100x throws is 3.74000.\\nThe std is 1.703354.\\nAs expected, 25% of the values of the dice throws are between 1 and 2.\\nAs more or less expected, 50% of the values of the dice throws are between 1 and 4 (ideally it'll be between 1 and 3 as we'll see afterwards).\\nAs expected, 75% of the values of the dice throws are between 1 and 5.\\n\"" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "I see the dice was thrown 100x.\n", + "The mean of these 100x throws is 3.74000.\n", + "The std is 1.703354.\n", + "As expected, 25% of the values of the dice throws are between 1 and 2.\n", + "As more or less expected, 50% of the values of the dice throws are between 1 and 4 (ideally it'll be between 1 and 3 as we'll see afterwards).\n", + "As expected, 75% of the values of the dice throws are between 1 and 5.\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Using the functions you defined in *challenge 2*, calculate the mean value of the hundred dice rolls." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Unnamed: 0 49.50\n", + "roll 49.50\n", + "value 3.74\n", + "dtype: float64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "mean_(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Now, calculate the frequency distribution.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1: Unnamed: 0 0.12\n", + "roll 0.12\n", + "value 0.12\n", + "dtype: float64, 2: Unnamed: 0 0.17\n", + "roll 0.17\n", + "value 0.17\n", + "dtype: float64, 3: Unnamed: 0 0.14\n", + "roll 0.14\n", + "value 0.14\n", + "dtype: float64, 4: Unnamed: 0 0.22\n", + "roll 0.22\n", + "value 0.22\n", + "dtype: float64, 5: Unnamed: 0 0.12\n", + "roll 0.12\n", + "value 0.12\n", + "dtype: float64, 6: Unnamed: 0 0.23\n", + "roll 0.23\n", + "value 0.23\n", + "dtype: float64}\n" + ] + }, + { + "data": { + "text/plain": [ + "1 12\n", + "2 17\n", + "3 14\n", + "4 22\n", + "5 12\n", + "6 23\n", + "Name: value, dtype: int64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "\n", + "#we can go through the complicated way...\n", + "freq_distrib=dict() #instantiate dict.\n", + "\n", + "for x in set(df['value']):\n", + " freq_distrib[x]=list(df['value']).count(x)/df.count() #create freq ratio for each key here.\n", + "\n", + "print(freq_distrib) \n", + "#mean will be equal to keys*values\n", + "sum( [ freq_distrib[x]*x for x in freq_distrib ] ) #multiplying all then summing afterwards the elements of the list.\n", + "\n", + "\n", + "#or a built in way...\n", + "pd.value_counts(df['value']).sort_index()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- Plot the histogram. What do you see (shape, values...) ? How can you connect the mean value to the histogram? " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "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\n", + "#if what is required is a histogram for the whole df then:\n", + "df.plot.hist()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#if what is required is a histogram for the values of the dice throws then:\n", + "df['value'].plot.hist()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 5.- Read the `roll_the_dice_thousand.csv` from the `data` folder. Plot the frequency distribution as you did before. Has anything changed? Why do you think it changed?" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "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", + "
Unnamed: 0rollvalue
count1000.0000001000.0000001000.000000
mean499.500000499.5000003.447000
std288.819436288.8194361.711175
min0.0000000.0000001.000000
25%249.750000249.7500002.000000
50%499.500000499.5000003.000000
75%749.250000749.2500005.000000
max999.000000999.0000006.000000
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 roll value\n", + "count 1000.000000 1000.000000 1000.000000\n", + "mean 499.500000 499.500000 3.447000\n", + "std 288.819436 288.819436 1.711175\n", + "min 0.000000 0.000000 1.000000\n", + "25% 249.750000 249.750000 2.000000\n", + "50% 499.500000 499.500000 3.000000\n", + "75% 749.250000 749.250000 5.000000\n", + "max 999.000000 999.000000 6.000000" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "df=pd.read_csv(\"roll_the_dice_thousand.csv\")\n", + "df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nI see the dice was thrown 100x.\\nThe mean of these 100x throws is 3.74000.\\nThe std is 1.703354.\\nAs expected, 25% of the values of the dice throws are between 1 and 2.\\nAs expected, 50% of the values of the dice throws are between 1 and 3.\\nAs expected, 75% of the values of the dice throws are between 1 and 5.\\n'" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "I see the dice was thrown 100x.\n", + "The mean of these 100x throws is 3.74000.\n", + "The std is 1.703354.\n", + "As expected, 25% of the values of the dice throws are between 1 and 2.\n", + "As expected, 50% of the values of the dice throws are between 1 and 3.\n", + "As expected, 75% of the values of the dice throws are between 1 and 5.\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 4\n", + "In the `data` folder of this repository you will find three different files with the prefix `ages_population`. These files contain information about a poll answered by a thousand people regarding their age. Each file corresponds to the poll answers in different neighbourhoods of Barcelona.\n", + "\n", + "#### 1.- Read the file `ages_population.csv`. Calculate the frequency distribution and plot it as we did during the lesson. Try to guess the range in which the mean and the standard deviation will be by looking at the plot. " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0 2\n", + "2.0 2\n", + "4.0 1\n", + "5.0 2\n", + "6.0 2\n", + " ..\n", + "69.0 1\n", + "70.0 1\n", + "71.0 1\n", + "73.0 1\n", + "82.0 1\n", + "Name: observation, Length: 72, dtype: int64\n" + ] + }, + { + "data": { + "text/plain": [ + "'\\nMean shall be circa 35.\\nStd shall be circa 10.\\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\n", + "df=pd.read_csv(\"ages_population.csv\")\n", + "\n", + "#we can compute the freq distrib this way:\n", + "freq_calc=pd.value_counts(df['observation']).sort_index()\n", + "print(freq_calc)\n", + "\n", + "#plot hist:\n", + "df.plot.hist()\n", + "\n", + "'''\n", + "Mean shall be circa 35.\n", + "Std shall be circa 10.\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "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", + "
observation
068.0
112.0
245.0
338.0
449.0
\n", + "
" + ], + "text/plain": [ + " observation\n", + "0 68.0\n", + "1 12.0\n", + "2 45.0\n", + "3 38.0\n", + "4 49.0" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Calculate the exact mean and standard deviation and compare them with your guesses. Do they fall inside the ranges you guessed?" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "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\n", + "print(df.mean())\n", + "print(df.std())" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nAnswer: yes, they fall.\\n'" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Answer: yes, they fall.\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Now read the file `ages_population2.csv` . Calculate the frequency distribution and plot it." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "19.0 3\n", + "20.0 13\n", + "21.0 17\n", + "22.0 35\n", + "23.0 41\n", + "24.0 78\n", + "25.0 98\n", + "26.0 120\n", + "27.0 125\n", + "28.0 139\n", + "29.0 115\n", + "30.0 90\n", + "31.0 61\n", + "32.0 31\n", + "33.0 22\n", + "34.0 7\n", + "35.0 3\n", + "36.0 2\n", + "Name: observation, dtype: int64\n" + ] + }, + { + "data": { + "text/plain": [ + "'\\nMean shall be circa 27.\\nStd shall be circa 5.\\n'" + ] + }, + "execution_count": 24, + "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\n", + "df=pd.read_csv(\"ages_population2.csv\")\n", + "\n", + "#we can compute the freq distrib this way:\n", + "freq_calc=pd.value_counts(df['observation']).sort_index()\n", + "print(freq_calc)\n", + "\n", + "#plot hist:\n", + "df.plot.hist()\n", + "'''\n", + "Mean shall be circa 27.\n", + "Std shall be circa 5.\n", + "'''" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- What do you see? Is there any difference with the frequency distribution in step 1?" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\nAnswer: yes, there are clear differences as we can see the way ages are distributed. \\nFirst we can see the range is way lower: between 20(min) and 35(max).\\nSecond, the data doesn't seem like a gaussian curve... it's skewed, kind of like having 3 peaks (1 major peak circa 27, 2 minor peaks)\\nRegarding its kurtosis: due to this more flattened distrib. we can see the kurtosis is clearly differente from the previos hist.\\n\\n\"" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Answer: yes, there are clear differences as we can see the way ages are distributed. \n", + "First we can see the range is way lower: between 20(min) and 35(max).\n", + "Second, the data doesn't seem like a gaussian curve... it's skewed, kind of like having 3 peaks (1 major peak circa 27, 2 minor peaks)\n", + "Regarding its kurtosis: due to this more flattened distrib. we can see the kurtosis is clearly differente from the previos hist.\n", + "\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 5.- Calculate the mean and standard deviation. Compare the results with the mean and standard deviation in step 2. What do you think?" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "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\n", + "print(df.mean())\n", + "print(df.std())" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\nAnswer: due to the more condensed/Flattened data we see that std will likely be inferior due to the previous analyzed data.\\nWe can also see that the mean that'd likely be circa 26 or 25 is actually 27.\\n\"" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Answer: due to the more condensed/Flattened data we see that std will likely be inferior due to the previous analyzed data.\n", + "We can also see that the mean that'd likely be circa 26 or 25 is actually 27.\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 5\n", + "Now is the turn of `ages_population3.csv`.\n", + "\n", + "#### 1.- Read the file `ages_population3.csv`. Calculate the frequency distribution and plot it." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAD4CAYAAAD2FnFTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAYNUlEQVR4nO3df5BU9Z3u8fcjoAjiijDJcgF3IMUqLCGDjiaLSokkLiEuavwFMYobyZhcKYm7qSy4alyrUuUmEVzLG128UUyuIiiCRrOboDcbQwrFIU4mg8j6I0hGuDBBF1RERT/3jz6DzeTA9PzoPgfmeVV19TnfPqf7sbuHx3P69GlFBGZmZm0dlnUAMzPLJxeEmZmlckGYmVkqF4SZmaVyQZiZWareWQfoisGDB0d1dXXWMczMDipr1679Y0RUtbfcQV0Q1dXV1NfXZx3DzOygIunVUpbzLiYzM0vlgjAzs1QuCDMzS3VQfwZhZgeH999/n+bmZnbv3p11lB6lb9++DBs2jD59+nRqfReEmZVdc3MzAwYMoLq6GklZx+kRIoLt27fT3NzMiBEjOnUf3sVkZmW3e/duBg0a5HKoIEkMGjSoS1ttLggzqwiXQ+V19Tl3QZiZWSp/BmFmFVc99/Fuvb+NN3+hc+tt3MjZZ59NU1NTt+bpqIaGBjZv3szUqVMBePTRR3n++eeZO3duprlcEHZI6+5/iDqis/9o2cFtz5499O7dsX9aGxoaqK+v31sQ06ZNY9q0aeWI1yHexWRmPcb8+fMZO3YsY8eO5dZbbwUK/6DPnDmTcePGccEFF7Br1y4A5s6dy5gxYxg3bhzf/OY3AWhpaeH888/n5JNP5uSTT+bXv/41ADfeeCN1dXWcddZZXHbZZXz6059m3bp1ex/3jDPOYO3ataxZs4YJEyYwfvx4JkyYwIYNG3jvvfe44YYbWLJkCTU1NSxZsoRFixYxe/ZsAF599VUmT57MuHHjmDx5Mps2bQLg8ssv5+qrr2bChAmMHDmShx56qNufLxeEmfUIa9eu5Z577uGZZ57h6aef5q677uKNN95gw4YN1NXV0djYyNFHH80PfvADXn/9dZYvX866detobGzkuuuuA2DOnDlcc801PPvssyxbtoxZs2btc/+PPPII999/P9OnT2fp0qUAbNmyhc2bN3PSSSdxwgkn8NRTT/Hcc89x0003ce2113L44Ydz0003cfHFF9PQ0MDFF1+8T+7Zs2dz2WWX0djYyCWXXMLVV1+997YtW7awatUqHnvssbLsjnJBmFmPsGrVKs477zz69+/PUUcdxRe/+EV+9atfMXz4cE499VQAvvzlL7Nq1SqOPvpo+vbty6xZs3j44Yfp168fAE888QSzZ8+mpqaGadOmsXPnTt58802gsFvoyCOPBOCiiy7iwQcfBGDp0qVceOGFAOzYsYMLL7yQsWPHcs011+yzlbE/q1ev5ktf+hIAl156KatWrdp727nnnsthhx3GmDFj2Lp1azc9Ux9xQZhZjxARqeNtDwWVRO/evVmzZg3nn38+K1asYMqUKQB8+OGHrF69moaGBhoaGnjttdcYMGAAAP379997H0OHDmXQoEE0NjayZMkSpk+fDsD111/PpEmTaGpq4ic/+UmnvqNQnPeII45o97+vK1wQZtYjTJw4kRUrVrBr1y7efvttli9fzumnn86mTZtYvXo1AIsXL+a0007jrbfeYseOHUydOpVbb72VhoYGAM466yxuv/32vffZOp5m+vTpfPe732XHjh188pOfBApbEEOHDgVg0aJFe5cdMGDA3i2RtiZMmMADDzwAwH333cdpp53W+Sehg3wUk5lVXBZHeJ144olcfvnlnHLKKQDMmjWLgQMHMnr0aO69916uvPJKRo0axde//nV27NjBOeecw+7du4kIFixYAMBtt93GVVddxbhx49izZw8TJ07kzjvvTH28Cy64gDlz5nD99dfvHfvWt77FzJkzmT9/Pmeeeebe8UmTJnHzzTdTU1PDvHnz9rmf2267ja985St873vfo6qqinvuuae7n5r9Ujk2SyqltrY2/INBdiA+zDUf1q9fz+jRo7OO0SOlPfeS1kZEbXvreheTmZmlckGYmVmqshWEpLslbZPUVDS2RFJDctkoqSEZr5b0TtFt6Tv1zOygdTDvzj5YdfU5L+eH1IuA24EftQ5ExN5vgEi6BdhRtPzLEVFTxjxmlpG+ffuyfft2n/K7glp/D6Jv376dvo+yFUREPCWpOu02Fd4hFwFnpt1uZoeWYcOG0dzcTEtLS9ZRepTWX5TrrKwOcz0d2BoRLxaNjZD0HLATuC4ifpW2oqQ6oA7guOOOK3tQM+u6Pn36dPpXzSw7WRXEDGBx0fwW4LiI2C7pJGCFpL+KiJ1tV4yIhcBCKBzmWpG0Zp2Q1SG2PrzWukvFj2KS1Bv4IrCkdSwi3o2I7cn0WuBl4C8rnc3MzD6SxWGunwVeiIjm1gFJVZJ6JdMjgVHAKxlkMzOzRDkPc10MrAaOl9Qs6Yrkpunsu3sJYCLQKOm3wEPA1yLi9XJlMzOz9pXzKKYZ+xm/PGVsGbCsXFnMzKzj/E1qMzNL5YIwM7NULggzM0vlgjAzs1QuCDMzS+WCMDOzVC4IMzNL5YIwM7NULggzM0vlgjAzs1QuCDMzS+WCMDOzVC4IMzNLldUvylkPk9Wvq5lZ53kLwszMUrkgzMwslQvCzMxSuSDMzCyVC8LMzFKVrSAk3S1pm6SmorEbJb0mqSG5TC26bZ6klyRtkPQ35cplZmalKecWxCJgSsr4goioSS4/BZA0BpgO/FWyzg8k9SpjNjMza0fZCiIingJeL3Hxc4AHIuLdiPg98BJwSrmymZlZ+7L4DGK2pMZkF9TAZGwo8IeiZZqTsT8hqU5SvaT6lpaWcmc1M+uxKl0QdwCfAGqALcAtybhSlo20O4iIhRFRGxG1VVVV5UlpZmaVLYiI2BoRH0TEh8BdfLQbqRkYXrToMGBzJbOZmdm+KloQkoYUzZ4HtB7h9CgwXdIRkkYAo4A1lcxmZmb7KtvJ+iQtBs4ABktqBr4NnCGphsLuo43AlQARsU7SUuB5YA9wVUR8UK5sZmbWvrIVRETMSBn+4QGW/w7wnXLlMTOzjvE3qc3MLJULwszMUrkgzMwslQvCzMxSuSDMzCyVC8LMzFK5IMzMLJULwszMUrkgzMwslQvCzMxSuSDMzCyVC8LMzFK5IMzMLFXZzuZqZtmonvt4Zo+98eYvZPbY1v28BWFmZqlcEGZmlsoFYWZmqVwQZmaWqmwFIeluSdskNRWNfU/SC5IaJS2XdEwyXi3pHUkNyeXOcuUyM7PSlHMLYhEwpc3YSmBsRIwD/guYV3TbyxFRk1y+VsZcZmZWgrIVREQ8BbzeZuznEbEnmX0aGFauxzczs67J8jOIrwD/XjQ/QtJzkn4p6fT9rSSpTlK9pPqWlpbypzQz66EyKQhJ/wTsAe5LhrYAx0XEeODvgfslHZ22bkQsjIjaiKitqqqqTGAzsx6o4gUhaSZwNnBJRARARLwbEduT6bXAy8BfVjqbmZl9pKIFIWkK8I/AtIjYVTReJalXMj0SGAW8UslsZma2r7Kdi0nSYuAMYLCkZuDbFI5aOgJYKQng6eSIpYnATZL2AB8AX4uI11Pv2MzMKqJsBRERM1KGf7ifZZcBy8qVxczMOq6kXUySxpY7iJmZ5Uupn0HcKWmNpP/Z+u1nMzM7tJVUEBFxGnAJMByol3S/pM+VNZmZmWWq5M8gIuJFSdcB9cBtwHgVPmm+NiIeLldAM7P2ZPUjSYf6DySV+hnEOEkLgPXAmcDfRsToZHpBGfOZmVlGSt2CuB24i8LWwjutgxGxOdmqMDOzQ0ypBTEVeCciPgCQdBjQNyJ2RcSPy5bOzMwyU+pRTE8ARxbN90vGzMzsEFVqQfSNiLdaZ5LpfuWJZGZmeVBqQbwt6cTWGUknAe8cYHkzMzvIlfoZxDeAByVtTuaHABeXJ5KZmeVBSQUREc9KOgE4HhDwQkS8X9ZkZmaWqY6crO9koDpZZ7wkIuJHZUllZmaZK6kgJP0Y+ATQQOF03AABuCDMzA5RpW5B1AJjWn8BzszMDn2lHsXUBPx5OYOYmVm+lLoFMRh4XtIa4N3WwYiYVpZUZmaWuVIL4sZyhjAzs/wp9TDXX0r6C2BURDwhqR/Qq7zRzMwsS6We7vurwEPAvyVDQ4EVJax3t6RtkpqKxo6VtFLSi8n1wGRckm6T9JKkxuJvbpuZWeWV+iH1VcCpwE4o/HgQ8LES1lsETGkzNhd4MiJGAU8m8wCfB0YllzrgjhKzmZlZGZRaEO9GxHutM5J6U/gexAFFxFPA622GzwHuTabvBc4tGv9RFDwNHCNpSIn5zMysm5VaEL+UdC1wZPJb1A8CP+nkY348IrYAJNetWyJDgT8ULdecjO1DUp2kekn1LS0tnYxgZmbtKbUg5gItwO+AK4GfAt39S3JKGfuTrZSIWBgRtRFRW1VV1c0RzMysValHMX1I4SdH7+qGx9wqaUhEbEl2IW1LxpuB4UXLDQM2/8naZmZWEaUexfR7Sa+0vXTyMR8FZibTM4FHisYvS45m+gywo3VXlJmZVV5HzsXUqi9wIXBseytJWgycAQyW1Ax8G7gZWCrpCmBTcl9Q2G01FXgJ2AX8XYnZzMysDErdxbS9zdCtklYBN7Sz3oz93DQ5ZdmgcDitmZnlQKmn+y7+0tphFLYoBpQlkZmZ5UKpu5huKZreA2wELur2NGZmlhul7mKaVO4gZmaWL6XuYvr7A90eEfO7J46ZmeVFR45iOpnCoagAfws8xb7ffDYzs0NIR34w6MSIeBNA0o3AgxExq1zBzMwsW6WeauM44L2i+feA6m5PY2ZmuVHqFsSPgTWSllM4P9J5wI/KlsrMzDJX6lFM35H078DpydDfRcRz5YtlZmZZK3UXE0A/YGdE/CvQLGlEmTKZmVkOlHqyvm8D/wjMS4b6AP+nXKHMzCx7pW5BnAdMA94GiIjN+FQbZmaHtFIL4r3kZHoBIKl/+SKZmVkelFoQSyX9G4Xfif4q8ATd8+NBZmaWU6UexfT95LeodwLHAzdExMqyJjMzs0y1WxCSegE/i4jPAi4FM7Meot1dTBHxAbBL0p9VII+ZmeVEqd+k3g38TtJKkiOZACLi6rKkMjOzzJVaEI8nFzuIVc/1S2hmpTtgQUg6LiI2RcS93fWAko4HlhQNjaTw29bHAF8FWpLxayPip931uGZm1jHtfQaxonVC0rLueMCI2BARNRFRA5wE7AKWJzcvaL3N5WBmlq32CkJF0yPL8PiTgZcj4tUy3LeZmXVBewUR+5nuLtOBxUXzsyU1Srpb0sC0FSTVSaqXVN/S0pK2iJmZdYP2CuJTknZKehMYl0zvlPSmpJ1deWBJh1M4v9ODydAdwCeAGmALcEvaehGxMCJqI6K2qqqqKxHMzOwADvghdUT0KuNjfx74TURsTR5ra+sNku4CHivjY5uZWTs68nsQ3W0GRbuXJA0puu08oKniiczMbK9SvwfRrST1Az4HXFk0/F1JNRQ+69jY5jYzM6uwTAoiInYBg9qMXZpFFjMzS5flLiYzM8sxF4SZmaVyQZiZWSoXhJmZpXJBmJlZKheEmZmlckGYmVkqF4SZmaVyQZiZWSoXhJmZpXJBmJlZKheEmZmlckGYmVkqF4SZmaXK5HTfZnZoqp77eNYRrBt5C8LMzFJ5C8LMrJOy3GLaePMXyv4Y3oIwM7NUmW1BSNoIvAl8AOyJiFpJxwJLgGoKv0t9UUS8kVVGM7OeLOstiEkRURMRtcn8XODJiBgFPJnMm5lZBrIuiLbOAe5Npu8Fzs0wi5lZj5ZlQQTwc0lrJdUlYx+PiC0AyfXH2q4kqU5SvaT6lpaWCsY1M+tZsjyK6dSI2CzpY8BKSS+UslJELAQWAtTW1kY5A5qZ9WSZbUFExObkehuwHDgF2CppCEByvS2rfGZmPV0mBSGpv6QBrdPAWUAT8CgwM1lsJvBIFvnMzCy7XUwfB5ZLas1wf0T8h6RngaWSrgA2ARdmlM/MrMfLpCAi4hXgUynj24HJlU9kZmZt5e0wVzMzywkXhJmZpXJBmJlZKheEmZmlckGYmVkqF4SZmaVyQZiZWSoXhJmZpXJBmJlZKheEmZmlckGYmVkqF4SZmaVyQZiZWaosf1Gux6qe+3jWEczM2uUtCDMzS+WCMDOzVC4IMzNL5YIwM7NULggzM0tV8YKQNFzSLyStl7RO0pxk/EZJr0lqSC5TK53NzMw+ksVhrnuAf4iI30gaAKyVtDK5bUFEfD+DTGZm1kbFCyIitgBbkuk3Ja0HhlY6h5mZHVimn0FIqgbGA88kQ7MlNUq6W9LA/axTJ6leUn1LS0uFkpqZ9TyZFYSko4BlwDciYidwB/AJoIbCFsYtaetFxMKIqI2I2qqqqorlNTPraTIpCEl9KJTDfRHxMEBEbI2IDyLiQ+Au4JQsspmZWUEWRzEJ+CGwPiLmF40PKVrsPKCp0tnMzOwjWRzFdCpwKfA7SQ3J2LXADEk1QAAbgSszyGZmZoksjmJaBSjlpp9WOouZme2fv0ltZmapXBBmZpbKBWFmZqlcEGZmlsoFYWZmqVwQZmaWygVhZmapXBBmZpbKBWFmZqlcEGZmlsoFYWZmqVwQZmaWygVhZmapsjjdd25Uz3086whmZrnlLQgzM0vlgjAzs1QuCDMzS+WCMDOzVC4IMzNLlbuCkDRF0gZJL0mam3UeM7OeKlcFIakX8L+AzwNjgBmSxmSbysysZ8pVQQCnAC9FxCsR8R7wAHBOxpnMzHqkvH1Rbijwh6L5ZuDTxQtIqgPqktm3JG3owP0PBv7YpYTl5Xxd43xd43xdU9F8+pcOr1Kc7y9KWSFvBaGUsdhnJmIhsLBTdy7VR0RtZ9atBOfrGufrGufrmkMxX952MTUDw4vmhwGbM8piZtaj5a0gngVGSRoh6XBgOvBoxpnMzHqkXO1iiog9kmYDPwN6AXdHxLpufIhO7ZqqIOfrGufrGufrmkMunyKi/aXMzKzHydsuJjMzywkXhJmZpeoRBZG303dIulvSNklNRWPHSlop6cXkemCG+YZL+oWk9ZLWSZqTp4yS+kpaI+m3Sb5/TsZHSHomybckOdAhM5J6SXpO0mN5yydpo6TfSWqQVJ+M5eL1TbIcI+khSS8k78O/zks+Sccnz1vrZaekb+QlX5LxmuRvo0nS4uRvpsPvv0O+IHJ6+o5FwJQ2Y3OBJyNiFPBkMp+VPcA/RMRo4DPAVclzlpeM7wJnRsSngBpgiqTPAP8CLEjyvQFckVG+VnOA9UXzecs3KSJqio6Nz8vrC/CvwH9ExAnApyg8j7nIFxEbkuetBjgJ2AUsz0s+SUOBq4HaiBhL4YCf6XTm/RcRh/QF+GvgZ0Xz84B5OchVDTQVzW8AhiTTQ4ANWWcsyvYI8Lk8ZgT6Ab+h8I37PwK90173DHINo/CPxJnAYxS+BJqnfBuBwW3GcvH6AkcDvyc5iCZv+dpkOgv4dZ7y8dEZKY6lcKTqY8DfdOb9d8hvQZB++o6hGWU5kI9HxBaA5PpjGecBQFI1MB54hhxlTHbfNADbgJXAy8B/R8SeZJGsX+dbgW8BHybzg8hXvgB+LmltcvoayM/rOxJoAe5JdtH9b0n9c5Sv2HRgcTKdi3wR8RrwfWATsAXYAaylE++/nlAQ7Z6+w9JJOgpYBnwjInZmnadYRHwQhU38YRRO8jg6bbHKpiqQdDawLSLWFg+nLJrl+/DUiDiRwq7XqyRNzDBLW72BE4E7ImI88DbZ7u5KlezDnwY8mHWWYslnH+cAI4D/AfSn8Dq31e77rycUxMFy+o6tkoYAJNfbsgwjqQ+FcrgvIh5OhnOVESAi/hv4TwqflRwjqfXLn1m+zqcC0yRtpHBG4jMpbFHkJR8RsTm53kZh//kp5Of1bQaaI+KZZP4hCoWRl3ytPg/8JiK2JvN5yfdZ4PcR0RIR7wMPAxPoxPuvJxTEwXL6jkeBmcn0TAr7/TMhScAPgfURMb/oplxklFQl6Zhk+kgKfxDrgV8AF2SdLyLmRcSwiKim8H77vxFxSV7ySeovaUDrNIX96E3k5PWNiP8H/EHS8cnQZOB5cpKvyAw+2r0E+cm3CfiMpH7J33Lr89fx91/WH/JU6EObqcB/UdhP/U85yLOYwr7B9yn839IVFPZRPwm8mFwfm2G+0yhsfjYCDcllal4yAuOA55J8TcANyfhIYA3wEoXN/iNy8FqfATyWp3xJjt8ml3WtfxN5eX2TLDVAffIarwAG5ixfP2A78GdFY3nK98/AC8nfx4+BIzrz/vOpNszMLFVP2MVkZmad4IIwM7NULggzM0vlgjAzs1QuCDMzS+WCMDOzVC4IMzNL9f8BToTuaCBSeawAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "df=pd.read_csv(\"ages_population3.csv\")\n", + "df.plot.hist()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Calculate the mean and standard deviation. Compare the results with the plot in step 1. What is happening?" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "observation 41.989\n", + "dtype: float64\n", + "observation 16.144706\n", + "dtype: float64\n", + "observation 40.0\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "# your code here\n", + "print(df.mean())\n", + "print(df.std())\n", + "print(df.median())" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nWe can see it is negatively skewed and that the mean is now 42.\\nThe std also increased significantly.\\n'" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "We can see it is negatively skewed and that the mean is now 42.\n", + "The std also increased significantly.\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Calculate the four quartiles. Use the results to explain your reasoning for question in step 2. How much of a difference is there between the median and the mean?" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " observation\n", + "0.25 30.0\n", + "0.50 40.0\n", + "0.75 53.0\n", + "1.00 77.0\n" + ] + } + ], + "source": [ + "# your code here\n", + "print(df.quantile([0.25,0.5,0.75,1.0]))\n", + "diff=float(df.mean())-float(df.median())" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "My answer is: We can see the difference between them is 1.9889999999999972. It isn't much...\n" + ] + } + ], + "source": [ + "print(f\"My answer is: We can see the difference between them is {diff}. It isn't much...\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- Calculate other percentiles that might be useful to give more arguments to your reasoning." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bonus challenge\n", + "Compare the information about the three neighbourhoods. Prepare a report about the three of them. Remember to find out which are their similarities and their differences backing your arguments in basic statistics." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/your-code/main.ipynb b/your-code/main.ipynb deleted file mode 100644 index a0a5b66..0000000 --- a/your-code/main.ipynb +++ /dev/null @@ -1,522 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Understanding Descriptive Statistics\n", - "\n", - "Import the necessary libraries here:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Libraries" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Challenge 1\n", - "#### 1.- Define a function that simulates rolling a dice 10 times. Save the information in a dataframe.\n", - "**Hint**: you can use the *choices* function from module *random* to help you with the simulation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.- Plot the results sorted by value." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3.- Calculate the frequency distribution and plot it. What is the relation between this plot and the plot above? Describe it with words." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Challenge 2\n", - "Now, using the dice results obtained in *challenge 1*, your are going to define some functions that will help you calculate the mean of your data in two different ways, the median and the four quartiles. \n", - "\n", - "#### 1.- Define a function that computes the mean by summing all the observations and dividing by the total number of observations. You are not allowed to use any methods or functions that directly calculate the mean value. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.- First, calculate the frequency distribution. Then, calculate the mean using the values of the frequency distribution you've just computed. You are not allowed to use any methods or functions that directly calculate the mean value. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3.- Define a function to calculate the median. You are not allowed to use any methods or functions that directly calculate the median value. \n", - "**Hint**: you might need to define two computation cases depending on the number of observations used to calculate the median." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 4.- Define a function to calculate the four quartiles. You can use the function you defined above to compute the median but you are not allowed to use any methods or functions that directly calculate the quartiles. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Challenge 3\n", - "Read the csv `roll_the_dice_hundred.csv` from the `data` folder.\n", - "#### 1.- Sort the values and plot them. What do you see?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.- Using the functions you defined in *challenge 2*, calculate the mean value of the hundred dice rolls." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3.- Now, calculate the frequency distribution.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 4.- Plot the histogram. What do you see (shape, values...) ? How can you connect the mean value to the histogram? " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 5.- Read the `roll_the_dice_thousand.csv` from the `data` folder. Plot the frequency distribution as you did before. Has anything changed? Why do you think it changed?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Challenge 4\n", - "In the `data` folder of this repository you will find three different files with the prefix `ages_population`. These files contain information about a poll answered by a thousand people regarding their age. Each file corresponds to the poll answers in different neighbourhoods of Barcelona.\n", - "\n", - "#### 1.- Read the file `ages_population.csv`. Calculate the frequency distribution and plot it as we did during the lesson. Try to guess the range in which the mean and the standard deviation will be by looking at the plot. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.- Calculate the exact mean and standard deviation and compare them with your guesses. Do they fall inside the ranges you guessed?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3.- Now read the file `ages_population2.csv` . Calculate the frequency distribution and plot it." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 4.- What do you see? Is there any difference with the frequency distribution in step 1?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 5.- Calculate the mean and standard deviation. Compare the results with the mean and standard deviation in step 2. What do you think?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Challenge 5\n", - "Now is the turn of `ages_population3.csv`.\n", - "\n", - "#### 1.- Read the file `ages_population3.csv`. Calculate the frequency distribution and plot it." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.- Calculate the mean and standard deviation. Compare the results with the plot in step 1. What is happening?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3.- Calculate the four quartiles. Use the results to explain your reasoning for question in step 2. How much of a difference is there between the median and the mean?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 4.- Calculate other percentiles that might be useful to give more arguments to your reasoning." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Bonus challenge\n", - "Compare the information about the three neighbourhoods. Prepare a report about the three of them. Remember to find out which are their similarities and their differences backing your arguments in basic statistics." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "ironhack-3.7", - "language": "python", - "name": "ironhack-3.7" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}