diff --git a/your-code/main.ipynb b/your-code/main.ipynb index 5759add..0a26d68 100644 --- a/your-code/main.ipynb +++ b/your-code/main.ipynb @@ -1,522 +1,1495 @@ -{ - "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 -} +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Understanding Descriptive Statistics\n", + "\n", + "Import the necessary libraries here:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np \n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "import sklearn" + ] + }, + { + "attachments": {}, + "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": [ + { + "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
01
11
22
31
44
55
62
71
83
96
\n", + "
" + ], + "text/plain": [ + " 0\n", + "0 1\n", + "1 1\n", + "2 2\n", + "3 1\n", + "4 4\n", + "5 5\n", + "6 2\n", + "7 1\n", + "8 3\n", + "9 6" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange (1,7,1)\n", + "lançamentos = []\n", + "for i in range(10):\n", + " lançamentos.append(random.choice(np.arange(1,7,1)))\n", + "\n", + "pd.DataFrame(lançamentos)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Plot the results sorted by value." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.arange (1,7,1)\n", + "lançamentos = []\n", + "for i in range(10):\n", + " lançamentos.append(random.choice(np.arange(1,7,1)))\n", + "\n", + "pd.DataFrame(lançamentos)\n", + "\n", + "\n", + "sorted_lançamentos = sorted(lançamentos)\n", + "\n", + "\n", + "df = pd.DataFrame(sorted_lançamentos, columns = ['Roll']) \n", + "df.plot(kind = 'bar', legend = None)\n", + "plt.xlabel('Roll Number')\n", + "plt.ylabel('Dice Value')\n", + "plt.title('Dice Roll Results (Sorted)')\n", + "\n", + "plt.show()\n" + ] + }, + { + "attachments": {}, + "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": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.arange (1,7,1)\n", + "lançamentos = []\n", + "for i in range(10):\n", + " lançamentos.append(random.choice(np.arange(1,7,1)))\n", + "\n", + "pd.DataFrame(lançamentos)\n", + "\n", + "\n", + "sorted_lançamentos = sorted(lançamentos)\n", + "\n", + "\n", + "df = pd.DataFrame(sorted_lançamentos, columns = ['Roll']) \n", + "frequency_distribuition = df['Roll'].value_counts().sort_index()\n", + "frequency_distribuition.plot (kind='bar')\n", + "plt.xlabel('Dice Value')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Dice Roll Frequency Distribuition')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "In comparison to the previous plot, which displayed the sorted dice roll values, i think this plot provides a clearer picture \n", + "of how frequently each dice value occurred in the 10 rolls.\n", + "\n", + "\"\"\"" + ] + }, + { + "attachments": {}, + "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": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_mean(lançamentos):\n", + " total = 0\n", + " count = 0\n", + "\n", + " for value in lançamentos:\n", + " total += value\n", + " count += 1\n", + "\n", + " if count == 0:\n", + " return None\n", + "\n", + " mean = total / count\n", + " print (mean)\n", + "\n" + ] + }, + { + "attachments": {}, + "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": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 2.9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\David Santos\\AppData\\Local\\Temp\\ipykernel_14504\\4223867082.py:16: FutureWarning: iteritems is deprecated and will be removed in a future version. Use .items instead.\n", + " for dice_value, frequency in frequency_distribuition.iteritems():\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(42) \n", + "lançamentos = []\n", + "for i in range (10): \n", + " lançamentos.append(random.choice(np.arange(1,7,1)))\n", + "\n", + "df = pd.DataFrame(lançamentos, columns = ['Roll'])\n", + "\n", + "sorted_lançamentos = sorted(lançamentos)\n", + "frequency_distribuition = pd.Series(sorted_lançamentos).value_counts()\n", + "\n", + "#mean using the frequency distribuition\n", + "\n", + "sum_products = 0 \n", + "sum_frequencies = 0 \n", + "\n", + "for dice_value, frequency in frequency_distribuition.iteritems(): \n", + " sum_products += dice_value * frequency \n", + " sum_frequencies += frequency \n", + "\n", + "mean = sum_products / sum_frequencies \n", + "print(\"Mean:\", mean)\n", + "\n", + "frequency_distribuition.plot(kind='bar')\n", + "plt.xlabel ('Dice Value')\n", + "plt.ylabel ('Frequency')\n", + "plt.title ('Dice Roll Frequency Distribuition')\n", + "\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "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": 16, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'length' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[16], line 6\u001b[0m\n\u001b[0;32m 2\u001b[0m sorted_data \u001b[39m=\u001b[39m \u001b[39msorted\u001b[39m(data)\n\u001b[0;32m 4\u001b[0m length \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(sorted_data) \n\u001b[1;32m----> 6\u001b[0m \u001b[39mif\u001b[39;00m length \u001b[39m%\u001b[39m \u001b[39m2\u001b[39m \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[0;32m 7\u001b[0m median \u001b[39m=\u001b[39m \u001b[39msorted\u001b[39m\u001b[39m.\u001b[39mdata[length \u001b[39m/\u001b[39m\u001b[39m/\u001b[39m \u001b[39m2\u001b[39m]\n\u001b[0;32m 8\u001b[0m \u001b[39melse\u001b[39;00m: \n", + "\u001b[1;31mNameError\u001b[0m: name 'length' is not defined" + ] + } + ], + "source": [ + "def calculate_median(data):\n", + " sorted_data = sorted(data)\n", + "\n", + " length = len(sorted_data) \n", + " \n", + "if length % 2 == 1:\n", + " median = sorted.data[length // 2]\n", + "else: \n", + " middle_right = sorted_data [length // 2]\n", + " middle_left = sorted_data [length // 2-1]\n", + " median = (middle_left + middle_right) / 2 \n", + "\n", + "return median " + ] + }, + { + "attachments": {}, + "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": [ + "def calculate_quartiles (data):\n", + " sorted_data = sorted(data)\n", + " length = len(sorted_data)\n", + "\n", + " q1_index = length // 4\n", + " q2_index = length // 2\n", + " q3_index = (length * 3) // 4\n", + "\n", + " if length % 2 == 1:\n", + " q1 = calculate_median(sorted_data[:q1_index])\n", + " q2 = calculate_median(sorted_data)\n", + " q3 = calculate_median(sorted_data[q3_index + 1:])\n", + " else: \n", + " q1 = calculate_median(sorted_data[:q1_index])\n", + " q2 = calculate_median(sorted_data)\n", + " q3 = calculate_median(sorted_data[q3_index:])\n", + "\n", + "return q1, q2, q3" + ] + }, + { + "attachments": {}, + "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": 28, + "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", + " \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": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "roll_dice = pd.read_csv('C:\\\\Users\\\\David Santos\\\\Desktop\\\\Labs IronHack\\\\8 - Descriptive-Stats\\\\data\\\\roll_the_dice_hundred.csv')\n", + "roll_dice" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6 23\n", + "4 22\n", + "2 17\n", + "3 14\n", + "1 12\n", + "5 12\n", + "Name: value, dtype: int64" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "roll_dice['value'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "16.666666666666668" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(roll_dice) / 6 " + ] + }, + { + "attachments": {}, + "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": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean (hundred rolls): 3.74\n" + ] + } + ], + "source": [ + "dice_rolls = roll_dice['value']\n", + "\n", + "mean_hundred_rolls = dice_rolls.mean() \n", + "\n", + "print (\"Mean (hundred rolls):\", mean_hundred_rolls)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Now, calculate the frequency distribution.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frequency Distribution:\n", + "1 12\n", + "2 17\n", + "3 14\n", + "4 22\n", + "5 12\n", + "6 23\n", + "Name: value, dtype: int64\n" + ] + } + ], + "source": [ + "dice_rolls = roll_dice['value']\n", + "\n", + "frequency_distribution = dice_rolls.value_counts().sort_index() \n", + "\n", + "print(\"Frequency Distribution:\")\n", + "print( frequency_distribution)\n" + ] + }, + { + "attachments": {}, + "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": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dice_rolls = roll_dice['value']\n", + "\n", + "frequency_distribution = dice_rolls.value_counts().sort_index()\n", + "\n", + "#histogram\n", + "\n", + "plt.bar(frequency_distribution.index, frequency_distribution.values)\n", + "plt.xlabel('Dice Value')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Dice roll frequency dist')\n", + "\n", + "mean_hundred_rolls = dice_rolls.mean() \n", + "\n", + "plt.axvline(x=mean_hundred_rolls, color = 'red', linestyle = '--', label = 'Mean' )\n", + "\n", + "plt.legend() \n", + "\n", + "plt.show() " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "The shape provide insights into the distributions characteristics. \n", + "Connecting the mean value to the histogram allows you to see where it falls within the distribution.\n", + "I also think it can provide insights of the distribution of the data.\n", + "\n", + "\"\"\"" + ] + }, + { + "attachments": {}, + "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": 45, + "metadata": {}, + "outputs": [], + "source": [ + "roll_dice2 = pd.read_csv('C:\\\\Users\\\\David Santos\\\\Desktop\\\\Labs IronHack\\\\8 - Descriptive-Stats\\\\data\\\\roll_the_dice_thousand.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1 175\n", + "3 175\n", + "4 168\n", + "2 167\n", + "6 166\n", + "5 149\n", + "Name: value, dtype: int64" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "roll_dice2['value'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "166.66666666666666" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(roll_dice2) / 6 " + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frequency Distribution:\n", + "1 175\n", + "2 167\n", + "3 175\n", + "4 168\n", + "5 149\n", + "6 166\n", + "Name: value, dtype: int64\n" + ] + } + ], + "source": [ + "dice_rolls2 = roll_dice2['value']\n", + "\n", + "frequency_distribution = dice_rolls2.value_counts().sort_index() \n", + "\n", + "print(\"Frequency Distribution:\")\n", + "print( frequency_distribution)\n" + ] + }, + { + "attachments": {}, + "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": 59, + "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", + "
observation
068.0
112.0
245.0
338.0
449.0
......
99527.0
99647.0
99753.0
99833.0
99931.0
\n", + "

1000 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " observation\n", + "0 68.0\n", + "1 12.0\n", + "2 45.0\n", + "3 38.0\n", + "4 49.0\n", + ".. ...\n", + "995 27.0\n", + "996 47.0\n", + "997 53.0\n", + "998 33.0\n", + "999 31.0\n", + "\n", + "[1000 rows x 1 columns]" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "population1 = pd.read_csv('C:\\\\Users\\\\David Santos\\\\Desktop\\\\Labs IronHack\\\\8 - Descriptive-Stats\\\\data\\\\ages_population.csv')\n", + "\n", + "population1" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frequency Distribution:\n", + "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" + ] + } + ], + "source": [ + "freqpop1 = population1['observation']\n", + "\n", + "frequency_distribution = freqpop1.value_counts().sort_index() \n", + "\n", + "print(\"Frequency Distribution:\")\n", + "print( frequency_distribution)" + ] + }, + { + "attachments": {}, + "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": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Population: 36.56\n" + ] + } + ], + "source": [ + "population1['observation'].value_counts()\n", + "\n", + "mean1 = population1['observation']\n", + "\n", + "mean_population = mean1.mean() \n", + "\n", + "print(\"Mean Population:\", mean_population)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard Deviation Population: 12.816499625976762\n" + ] + } + ], + "source": [ + "mean1 = population1['observation']\n", + "\n", + "standard_deviation_population = mean1.std() \n", + "\n", + "print(\"Standard Deviation Population:\", standard_deviation_population )" + ] + }, + { + "attachments": {}, + "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": 58, + "metadata": {}, + "outputs": [], + "source": [ + "population2 = pd.read_csv('C:\\\\Users\\\\David Santos\\\\Desktop\\\\Labs IronHack\\\\8 - Descriptive-Stats\\\\data\\\\ages_population2.csv')" + ] + }, + { + "attachments": {}, + "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": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frequency Distribution:\n", + "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": [ + "Text(0.5, 1.0, 'Observation Frequency Distribution')" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "freqpop2 = population2['observation']\n", + "\n", + "frequency_distribution = freqpop2.value_counts().sort_index() \n", + "\n", + "print(\"Frequency Distribution:\")\n", + "print( frequency_distribution)\n", + "\n", + "plt.bar(frequency_distribuition.index, frequency_distribuition.values)\n", + "plt.xlabel('Observation')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Observation Frequency Distribution')\n", + "# the freq dist on the frist was between 1 and 2, and now it has more values. \n" + ] + }, + { + "attachments": {}, + "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": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Population: 27.155\n" + ] + } + ], + "source": [ + "population2['observation'].value_counts()\n", + "\n", + "mean2 = population2['observation']\n", + "\n", + "mean_population2 = mean2.mean() \n", + "\n", + "print(\"Mean Population:\", mean_population2)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard Deviation Population: 2.969813932689186\n" + ] + } + ], + "source": [ + "mean2 = population2['observation']\n", + "\n", + "standard_deviation_population2 = mean2.std() \n", + "\n", + "print(\"Standard Deviation Population:\", standard_deviation_population2 )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "The mean fall from 36,56 to 27,155 and the std dev from 12,8 to 2,9\n", + "\"\"\"" + ] + }, + { + "attachments": {}, + "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": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frequency Distribution:\n", + "1.0 1\n", + "2.0 2\n", + "4.0 2\n", + "5.0 1\n", + "7.0 1\n", + " ..\n", + "73.0 6\n", + "74.0 6\n", + "75.0 2\n", + "76.0 1\n", + "77.0 2\n", + "Name: observation, Length: 75, dtype: int64\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Observation Frequency Distribution')" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "population3 = pd.read_csv('C:\\\\Users\\\\David Santos\\\\Desktop\\\\Labs IronHack\\\\8 - Descriptive-Stats\\\\data\\\\ages_population3.csv')\n", + "\n", + "freqpop3 = population3['observation']\n", + "\n", + "frequency_distribution = freqpop3.value_counts().sort_index() \n", + "\n", + "print(\"Frequency Distribution:\")\n", + "print( frequency_distribution)\n", + "\n", + "plt.bar(frequency_distribuition.index, frequency_distribuition.values)\n", + "plt.xlabel('Observation')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Observation Frequency Distribution')\n" + ] + }, + { + "attachments": {}, + "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": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Population: 41.989\n" + ] + } + ], + "source": [ + "population3['observation'].value_counts()\n", + "\n", + "mean3 = population3['observation']\n", + "\n", + "mean_population3 = mean3.mean() \n", + "\n", + "print(\"Mean Population:\", mean_population3)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard Deviation Population: 16.144705959865934\n" + ] + } + ], + "source": [ + "mean3 = population3['observation']\n", + "\n", + "standard_deviation_population3 = mean3.std() \n", + "\n", + "print(\"Standard Deviation Population:\", standard_deviation_population3 )" + ] + }, + { + "attachments": {}, + "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": 75, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First Quartile (Q1): 30.0\n", + "Second Quartile (Q2 / Median): 40.0\n", + "Third Quartile (Q3): 53.0\n", + "Fourth Quartile (Q4): 77.0\n" + ] + } + ], + "source": [ + "observation3 = population3['observation']\n", + "\n", + "quartile_1 = observation3.quantile(0.25)\n", + "quartile_2 = observation3.quantile(0.5)\n", + "quartile_3 = observation3.quantile(0.75)\n", + "quartile_4 = observation3.quantile(1)\n", + "\n", + "print(\"First Quartile (Q1):\", quartile_1)\n", + "\n", + "print(\"Second Quartile (Q2 / Median):\", quartile_2)\n", + "\n", + "print(\"Third Quartile (Q3):\", quartile_3)\n", + "\n", + "print(\"Fourth Quartile (Q4):\", quartile_4)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference between median and mean: -1.9889999999999972\n" + ] + } + ], + "source": [ + "mean_population3 = observation3.mean() \n", + "median_population3 = observation3.median()\n", + "\n", + "difference = median_population3 - mean_population3 \n", + "\n", + "print(\"Difference between median and mean:\", difference )" + ] + }, + { + "attachments": {}, + "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": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quartiles:\n", + "Q1: 30.0\n", + "Q2 (Median): 40.0\n", + "Q3: 53.0\n", + "\n", + "Additional Percentiles:\n", + "10th percentile (P10): 22.0\n", + "90th percentile (P90): 67.0\n", + "Minimum Value: 1.0\n", + "Maximum Value: 77.0\n" + ] + } + ], + "source": [ + "quartile_1 = observation3.quantile(0.25)\n", + "quartile_2 = observation3.quantile(0.5)\n", + "quartile_3 = observation3.quantile(0.75)\n", + "\n", + "percentile_10 = observation3.quantile(0.1)\n", + "percentile_90 = observation3.quantile(0.9)\n", + "\n", + "minimum = observation3.min() \n", + "maximum = observation3.max() \n", + "\n", + "\n", + "print(\"Quartiles:\")\n", + "print(\"Q1:\", quartile_1)\n", + "print(\"Q2 (Median):\", quartile_2)\n", + "print(\"Q3:\", quartile_3)\n", + "print(\"\")\n", + "\n", + "print(\"Additional Percentiles:\")\n", + "print(\"10th percentile (P10):\", percentile_10)\n", + "print(\"90th percentile (P90):\", percentile_90)\n", + "\n", + "print(\"Minimum Value:\", minimum)\n", + "print(\"Maximum Value:\", maximum)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "attachments": {}, + "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": "base", + "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.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}