From aafd0c4e5a6b504ad846f05ca0d4de1829ef5a93 Mon Sep 17 00:00:00 2001 From: alvarogracio Date: Thu, 11 May 2023 14:09:59 +0100 Subject: [PATCH] lab! --- .../.ipynb_checkpoints/main-checkpoint.ipynb | 524 +++++++++++++++++ your-code/main.ipynb | 541 +++++++++++++++--- 2 files changed, 990 insertions(+), 75 deletions(-) create mode 100644 your-code/.ipynb_checkpoints/main-checkpoint.ipynb diff --git a/your-code/.ipynb_checkpoints/main-checkpoint.ipynb b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb new file mode 100644 index 0000000..9937434 --- /dev/null +++ b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb @@ -0,0 +1,524 @@ +{ + "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\n", + "\n" + ] + }, + { + "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\n", + "\n" + ] + }, + { + "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": "Python 3 (ipykernel)", + "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.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/your-code/main.ipynb b/your-code/main.ipynb index a0a5b66..1de15ce 100644 --- a/your-code/main.ipynb +++ b/your-code/main.ipynb @@ -11,11 +11,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "# Libraries" + "# Libraries\n", + "import random\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n" ] }, { @@ -29,11 +32,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ - "# your code here" + "# your code here\n", + "\n", + "def roll_dice():\n", + " rolls = []\n", + " for i in range(10):\n", + " roll = random.randint(1, 6)\n", + " rolls.append(roll)\n", + " df = pd.DataFrame({'Rolls': rolls})\n", + " return df\n", + "\n" ] }, { @@ -45,11 +57,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "df = roll_dice()\n", + "df_sorted = df.sort_values(by='Rolls')\n", + "\n", + "\n", + "plt.plot(df_sorted.index, df_sorted['Rolls'], 'bo-')\n", + "plt.xlabel('Roll')\n", + "plt.ylabel('Value')\n", + "plt.title('Rolling a Dice 10 Times')\n", + "plt.show()" ] }, { @@ -61,11 +93,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "df_freq = df['Rolls'].value_counts().sort_index()\n", + "plt.subplot(1, 2, 2)\n", + "plt.bar(df_freq.index, df_freq.values)\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Roll Frequency Distribution')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" ] }, { @@ -76,6 +128,9 @@ "source": [ "\"\"\"\n", "your comments here\n", + "\n", + "the first plot shows the values of the rolls in the order they were rolled, \n", + "the second plot shows the frequency of each value in the rolls\n", "\"\"\"" ] }, @@ -91,11 +146,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "# your code here" + "# your code here\n", + "\n", + "def mean(observations):\n", + " total = 0\n", + " for obs in obsservations:\n", + " total += obs\n", + " return total / len(observations)\n" ] }, { @@ -107,11 +168,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of the rolls: 3.6\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "\n", + "rolls = []\n", + "for i in range(10):\n", + " roll = random.randint(1, 6)\n", + " rolls.append(roll)\n", + " \n", + "freq_dist = {}\n", + "for roll in rolls:\n", + " if roll not in freq_dist:\n", + " freq_dist[roll] = 1\n", + " else:\n", + " freq_dist[roll] += 1\n", + "\n", + "total = 0\n", + "num_rolls = 0\n", + "for value, freq in freq_dist.items():\n", + " total += value * freq\n", + " num_rolls += freq\n", + " \n", + "mean = total / num_rolls\n", + "print(\"Mean of the rolls:\", mean)\n", + "\n" ] }, { @@ -124,11 +215,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ - "# your code here" + "# your code here\n", + "\n", + "def calc_median(data):\n", + " \n", + " sorted_data = sorted(data)\n", + " num_observations = len(sorted_data)\n", + " \n", + " if num_observations % 2 == 0:\n", + " middle_index_1 = num_observations // 2 - 1\n", + " middle_index_2 = num_observations // 2\n", + " median = (sorted_data[middle_index_1] + sorted_data[middle_index_2]) / 2\n", + " else:\n", + " middle_index = num_observations // 2\n", + " median = sorted_data[middle_index]\n", + " \n", + " return median\n" ] }, { @@ -140,11 +246,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ - "# your code here" + "# your code here\n", + "def calculate_quartiles(data):\n", + " sorted_data = sorted(data)\n", + " \n", + " num_observations = len(sorted_data)\n", + " if num_observations % 2 == 0:\n", + " middle_index_1 = num_observations // 2 - 1\n", + " middle_index_2 = num_observations // 2\n", + " q2 = (sorted_data[middle_index_1] + sorted_data[middle_index_2]) / 2\n", + " else:\n", + " middle_index = num_observations // 2\n", + " q2 = sorted_data[middle_index]\n", + " \n", + " lower_half = sorted_data[:middle_index_2]\n", + " if len(lower_half) % 2 == 0:\n", + " middle_index_1 = len(lower_half) // 2 - 1\n", + " middle_index_2 = len(lower_half) // 2\n", + " q1 = (lower_half[middle_index_1] + lower_half[middle_index_2]) / 2\n", + " else:\n", + " middle_index = len(lower_half) // 2\n", + " q1 = lower_half[middle_index]\n", + " \n", + " upper_half = sorted_data[middle_index_2:]\n", + " if len(upper_half) % 2 == 0:\n", + " middle_index_1 = len(upper_half) // 2 - 1\n", + " middle_index_2 = len(upper_half) // 2\n", + " q3 = (upper_half[middle_index_1] + upper_half[middle_index_2]) / 2\n", + " else:\n", + " middle_index = len(upper_half) // 2\n", + " q3 = upper_half[middle_index]\n", + " \n", + " return q1, q2, q3\n" ] }, { @@ -158,22 +295,56 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" + "execution_count": 40, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "\n", + "data = pd.read_csv('C:\\\\Users\\\\farma\\Desktop\\\\iron hack\\\\week4\\\\lab\\\\Descriptive-Stats\\\\data\\\\roll_the_dice_hundred.csv')\n", + "\n", + "df_sorted = df.sort_values('value')\n", + "\n", + "plt.plot(df_sorted['roll'], df_sorted['value'], 'o')\n", + "plt.xlabel('Roll')\n", + "plt.ylabel('Value')\n", + "plt.title('Roll ')\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nThe scatter plot shows that each value appears multiple times\\n'" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\"\"\"\n", - "your comments here\n", - "\"\"\"" + "The scatter plot shows that each value appears multiple times\n", + "\"\"\"\n" ] }, { @@ -185,11 +356,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "3.74" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# your code here" + "\n", + "freq_dist = df['value'].value_counts().sort_index()\n", + "\n", + "mean = sum(freq_dist.index * freq_dist.values) / sum(freq_dist.values)\n", + "\n", + "mean" ] }, { @@ -201,11 +388,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 12\n", + "2 17\n", + "3 14\n", + "4 22\n", + "5 12\n", + "6 23\n", + "Name: value, dtype: int64\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "freq_dist = df['value'].value_counts().sort_index()\n", + "\n", + "freq_dist" ] }, { @@ -217,11 +421,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 53, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "\n", + "plt.hist(df['value'], bins=6, align='left', rwidth=0.8)\n", + "\n", + "plt.axvline(mean, color='red', linestyle='dashed', linewidth=1)\n", + "plt.show()\n" ] }, { @@ -231,8 +451,7 @@ "outputs": [], "source": [ "\"\"\"\n", - "your comments here\n", - "\"\"\"" + "The mean value is roughly in the middle of the distribution, which is expected given that the values are evenly distributed between 1 and 6.\"\"\"" ] }, { @@ -244,11 +463,37 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.447\n" + ] + } + ], + "source": [ + "# your code here\n", + "data = pd.read_csv('C:\\\\Users\\\\farma\\Desktop\\\\iron hack\\\\week4\\\\lab\\\\Descriptive-Stats\\\\data\\\\roll_the_dice_thousand.csv')\n", + "\n", + "mean = data['value'].mean()\n", + "plt.hist(data['value'], bins=6, align='left', rwidth=0.8)\n", + "\n", + "plt.axvline(mean, color='red', linestyle='dashed', linewidth=1)\n", + "plt.show()\n", + "print(mean)" ] }, { @@ -258,6 +503,7 @@ "outputs": [], "source": [ "\"\"\"\n", + "the mean tends to be closer to 3.5, this is because with a larger number of rolls, the distribution of the dice values should be more evenly distributed.\n", "your comments here\n", "\"\"\"" ] @@ -274,11 +520,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# your code here" + "# your code here\n", + "\n", + "data = pd.read_csv('C:\\\\Users\\\\farma\\Desktop\\\\iron hack\\\\week4\\\\lab\\\\Descriptive-Stats\\\\data\\\\ages_population.csv')\n", + "\n", + "data.head()\n", + "\n", + "\n", + "\n", + "freq_dist = data[\"observation\"].value_counts().sort_index()\n", + "plt.bar(freq_dist.index, freq_dist.values)\n", + "plt.show()\n", + "\n", + "# mean will be somewhere around 36-44 , and the std dev around 10-15" ] }, { @@ -290,11 +559,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 36.56\n", + "Standard deviation: 12.816499625976762\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "# Calculate the mean\n", + "mean = data[\"observation\"].mean()\n", + "\n", + "# Calculate the standard deviation\n", + "std_dev = data[\"observation\"].std()\n", + "\n", + "print(\"Mean:\", mean)\n", + "print(\"Standard deviation:\", std_dev)" ] }, { @@ -304,7 +590,7 @@ "outputs": [], "source": [ "\"\"\"\n", - "your comments here\n", + "your comments here yes, more a less\n", "\"\"\"" ] }, @@ -317,11 +603,53 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAnJ0lEQVR4nO3df3RU5Z3H8c8IYUjYEGVSZ0hJaHoMPwRKu+iyRLfEAqGsEfdwutQiSFvqoYvQZsEike0aPJogrpieUKnsuoQjpXj2CC7HbruERQGNWyHIFmiIv1ImCrM5k6YJMckkTZ79g83UIb8IvUOeTN6vc+453nuf+c4zD9fLhzt37uMyxhgBAABY5IaB7gAAAMCVCCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsMH+gOXIuOjg5duHBBiYmJcrlcA90dAABwFYwxunTpklJSUnTDDb1fIxmUAeXChQtKTU0d6G4AAIBrUF1drXHjxvXaZlAGlMTEREmXP+Do0aMHuDcAAOBqNDQ0KDU1Nfz3eG8GZUDp/Fpn9OjRBBQAAAaZq7k9g5tkAQCAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADr9DugHD16VPfcc49SUlLkcrn0yiuv9Nh25cqVcrlcKioqitgeCoW0Zs0aJScna9SoUVq4cKE++uij/nYFAADEqH4HlE8++UTTp0/Xtm3bem33yiuv6Fe/+pVSUlK67MvNzdX+/fu1d+9evfHGG2psbFROTo7a29v72x0AABCD+v2o+wULFmjBggW9tvn444+1evVq/ed//qfuvvvuiH319fV64YUX9OKLL2ru3LmSpN27dys1NVWHDh3S/Pnz+9slAAAQYxy/B6Wjo0PLli3TD37wA02ZMqXL/vLycrW1tSk7Ozu8LSUlRVOnTlVZWVm3NUOhkBoaGiIWAAAQuxwPKE899ZSGDx+u733ve93uDwQCGjFihG666aaI7V6vV4FAoNvXFBYWKikpKbykpqY63W0AAGARR2czLi8v149+9COdPHnyqmYq/DRjTI+vycvL09q1a8PrndM1A4hNfr9fwWAwKrWTk5OVlpYWldoAnONoQDl27Jhqamoi/udvb2/XunXrVFRUpN/+9rfy+XxqbW1VXV1dxFWUmpoaZWZmdlvX7XbL7XY72VUAlvL7/Zo4abJampuiUn9kfIIqz1UQUgDLORpQli1bFr7xtdP8+fO1bNkyfetb35IkzZgxQ3FxcSotLdXixYslSRcvXtSZM2e0ZcsWJ7sDYBAKBoNqaW6SJ2ed4jzOXiltq61W7avPKBgMElAAy/U7oDQ2Nur9998Pr1dVVenUqVMaM2aM0tLS5PF4ItrHxcXJ5/Np4sSJkqSkpCStWLFC69atk8fj0ZgxY/Twww9r2rRpXcINgKErzpMqt++Wge4GgAHS74By4sQJ3XXXXeH1zntDli9frpKSkquq8eyzz2r48OFavHixmpubNWfOHJWUlGjYsGH97Q4AAIhB/Q4oWVlZMsZcdfvf/va3XbaNHDlSxcXFKi4u7u/bAwCAIYC5eAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArDN8oDsAYPDy+/0KBoOO1qyoqHC0HoDBiYAC4Jr4/X5NnDRZLc1NA90VADGIgALgmgSDQbU0N8mTs05xnlTH6jZ/eEL1x3Y7Vg/A4ERAAfAnifOkyu27xbF6bbXVjtUCMHhxkywAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOv0O6AcPXpU99xzj1JSUuRyufTKK6+E97W1temRRx7RtGnTNGrUKKWkpOiBBx7QhQsXImqEQiGtWbNGycnJGjVqlBYuXKiPPvroT/4wAAAgNvQ7oHzyySeaPn26tm3b1mVfU1OTTp48qR/+8Ic6efKk9u3bp3fffVcLFy6MaJebm6v9+/dr7969euONN9TY2KicnBy1t7df+ycBAAAxo9/PQVmwYIEWLFjQ7b6kpCSVlpZGbCsuLtZf/MVfyO/3Ky0tTfX19XrhhRf04osvau7cuZKk3bt3KzU1VYcOHdL8+fOv4WMAAIBYEvUHtdXX18vlcunGG2+UJJWXl6utrU3Z2dnhNikpKZo6darKysq6DSihUEihUCi83tDQEO1uAzEjGvPlSMyZAyC6ohpQWlpatGHDBi1ZskSjR4+WJAUCAY0YMUI33XRTRFuv16tAINBtncLCQm3atCmaXQViEvPlABisohZQ2tradN9996mjo0PPPfdcn+2NMXK5XN3uy8vL09q1a8PrDQ0NSk11bu4PIFZFa74ciTlzAERXVAJKW1ubFi9erKqqKh0+fDh89USSfD6fWltbVVdXF3EVpaamRpmZmd3Wc7vdcrvd0egqMCQ4PV+OxJw5AKLL8eegdIaT9957T4cOHZLH44nYP2PGDMXFxUXcTHvx4kWdOXOmx4ACAACGln5fQWlsbNT7778fXq+qqtKpU6c0ZswYpaSk6Gtf+5pOnjypV199Ve3t7eH7SsaMGaMRI0YoKSlJK1as0Lp16+TxeDRmzBg9/PDDmjZtWvhXPQAAYGjrd0A5ceKE7rrrrvB6570hy5cvV35+vg4cOCBJ+uIXvxjxutdee01ZWVmSpGeffVbDhw/X4sWL1dzcrDlz5qikpETDhg27xo8BAABiSb8DSlZWlowxPe7vbV+nkSNHqri4WMXFxf19ewAAMAQwFw8AALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOtEfbJAALBNNCY6TE5OVlpamuN1gaGKgAJgyGhvrJNcLi1dutTx2iPjE1R5roKQAjiEgAJgyOgINUrGOD55YltttWpffUbBYJCAAjiEgAJgyInG5IkAnMVNsgAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6/Q7oBw9elT33HOPUlJS5HK59Morr0TsN8YoPz9fKSkpio+PV1ZWls6ePRvRJhQKac2aNUpOTtaoUaO0cOFCffTRR3/SBwEAALGj3wHlk08+0fTp07Vt27Zu92/ZskVbt27Vtm3bdPz4cfl8Ps2bN0+XLl0Kt8nNzdX+/fu1d+9evfHGG2psbFROTo7a29uv/ZMAAICYMby/L1iwYIEWLFjQ7T5jjIqKirRx40YtWrRIkrRr1y55vV7t2bNHK1euVH19vV544QW9+OKLmjt3riRp9+7dSk1N1aFDhzR//vw/4eMAAIBY4Og9KFVVVQoEAsrOzg5vc7vdmj17tsrKyiRJ5eXlamtri2iTkpKiqVOnhttcKRQKqaGhIWIBAACxy9GAEggEJElerzdiu9frDe8LBAIaMWKEbrrpph7bXKmwsFBJSUnhJTU11cluAwAAy0TlVzwulyti3RjTZduVemuTl5en+vr68FJdXe1YXwEAgH0cDSg+n0+SulwJqampCV9V8fl8am1tVV1dXY9truR2uzV69OiIBQAAxC5HA0p6erp8Pp9KS0vD21pbW3XkyBFlZmZKkmbMmKG4uLiINhcvXtSZM2fCbQAAwNDW71/xNDY26v333w+vV1VV6dSpUxozZozS0tKUm5urgoICZWRkKCMjQwUFBUpISNCSJUskSUlJSVqxYoXWrVsnj8ejMWPG6OGHH9a0adPCv+oBhiK/369gMOhozYqKCkfrAcD10u+AcuLECd11113h9bVr10qSli9frpKSEq1fv17Nzc1atWqV6urqNHPmTB08eFCJiYnh1zz77LMaPny4Fi9erObmZs2ZM0clJSUaNmyYAx8JGHz8fr8mTpqsluamge4KAFih3wElKytLxpge97tcLuXn5ys/P7/HNiNHjlRxcbGKi4v7+/ZATAoGg2ppbpInZ53iPM79Sq35wxOqP7bbsXoAcL30O6AAiJ44T6rcvlscq9dWyy/eAAxOTBYIAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWGf4QHcAAGJFRUVFVOomJycrLS0tKrUBWxFQAOBP1N5YJ7lcWrp0aVTqj4xPUOW5CkIKhhQCCgD8iTpCjZIx8uSsU5wn1dHabbXVqn31GQWDQQIKhhQCCgA4JM6TKrfvloHuBhATuEkWAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1nE8oPzhD3/QP/zDPyg9PV3x8fH6/Oc/r8cff1wdHR3hNsYY5efnKyUlRfHx8crKytLZs2ed7goAABikHA8oTz31lH7yk59o27Ztqqio0JYtW/T000+ruLg43GbLli3aunWrtm3bpuPHj8vn82nevHm6dOmS090BAACDkOMB5a233tK9996ru+++W5/73Of0ta99TdnZ2Tpx4oSky1dPioqKtHHjRi1atEhTp07Vrl271NTUpD179jjdHQAAMAg5HlDuvPNO/dd//ZfeffddSdL//M//6I033tBf//VfS5KqqqoUCASUnZ0dfo3b7dbs2bNVVlbWbc1QKKSGhoaIBQAAxK7hThd85JFHVF9fr0mTJmnYsGFqb2/Xk08+qW984xuSpEAgIEnyer0Rr/N6vTp//ny3NQsLC7Vp0yanuwoAACzl+BWUl156Sbt379aePXt08uRJ7dq1S//0T/+kXbt2RbRzuVwR68aYLts65eXlqb6+PrxUV1c73W0AAGARx6+g/OAHP9CGDRt03333SZKmTZum8+fPq7CwUMuXL5fP55N0+UrK2LFjw6+rqanpclWlk9vtltvtdrqrAADAUo5fQWlqatINN0SWHTZsWPhnxunp6fL5fCotLQ3vb21t1ZEjR5SZmel0dwAAwCDk+BWUe+65R08++aTS0tI0ZcoUvfPOO9q6dau+/e1vS7r81U5ubq4KCgqUkZGhjIwMFRQUKCEhQUuWLHG6Oxii/H6/gsGg43WTk5OVlpbmeF0AQCTHA0pxcbF++MMfatWqVaqpqVFKSopWrlypf/zHfwy3Wb9+vZqbm7Vq1SrV1dVp5syZOnjwoBITE53uDoYgv9+viZMmq6W5yfHaI+MTVHmugpACAFHmeEBJTExUUVGRioqKemzjcrmUn5+v/Px8p98eUDAYVEtzkzw56xTnSXWsbltttWpffUbBYJCAAgBR5nhAAWwR50mV23fLQHcDAHANmCwQAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDpRCSgff/yxli5dKo/Ho4SEBH3xi19UeXl5eL8xRvn5+UpJSVF8fLyysrJ09uzZaHQFAAAMQsOdLlhXV6c77rhDd911l37xi1/o5ptv1gcffKAbb7wx3GbLli3aunWrSkpKNGHCBD3xxBOaN2+eKisrlZiY6HSXAAA98Pv9CgaDjtdNTk5WWlqa43UxdDgeUJ566imlpqZq586d4W2f+9znwv9tjFFRUZE2btyoRYsWSZJ27dolr9erPXv2aOXKlU53CQDQDb/fr4mTJqulucnx2iPjE1R5roKQgmvmeEA5cOCA5s+fr7/927/VkSNH9NnPflarVq3Sgw8+KEmqqqpSIBBQdnZ2+DVut1uzZ89WWVlZtwElFAopFAqF1xsaGpzuNgAMOcFgUC3NTfLkrFOcJ9Wxum211ap99RkFg0ECCq6Z4wHlww8/1Pbt27V27Vo9+uijevvtt/W9731PbrdbDzzwgAKBgCTJ6/VGvM7r9er8+fPd1iwsLNSmTZuc7ioAQFKcJ1Vu3y0D3Q0gguM3yXZ0dOjP//zPVVBQoC996UtauXKlHnzwQW3fvj2incvlilg3xnTZ1ikvL0/19fXhpbq62uluAwAAizgeUMaOHatbb701YtvkyZPl9/slST6fT5LCV1I61dTUdLmq0sntdmv06NERCwAAiF2OB5Q77rhDlZWVEdveffddjR8/XpKUnp4un8+n0tLS8P7W1lYdOXJEmZmZTncHAAAMQo7fg/L3f//3yszMVEFBgRYvXqy3335bO3bs0I4dOyRd/monNzdXBQUFysjIUEZGhgoKCpSQkKAlS5Y43R0AADAIOR5Qbr/9du3fv195eXl6/PHHlZ6erqKiIt1///3hNuvXr1dzc7NWrVqluro6zZw5UwcPHuQZKAAAQFIUAook5eTkKCcnp8f9LpdL+fn5ys/Pj8bbAwCAQY65eAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrDI/2GxQWFurRRx/V97//fRUVFUmSjDHatGmTduzYobq6Os2cOVM//vGPNWXKlGh3Bxbx+/0KBoOO162oqHC8JgDg+opqQDl+/Lh27NihL3zhCxHbt2zZoq1bt6qkpEQTJkzQE088oXnz5qmyslKJiYnR7BIs4ff7NXHSZLU0Nw10VwAAFopaQGlsbNT999+vf/7nf9YTTzwR3m6MUVFRkTZu3KhFixZJknbt2iWv16s9e/Zo5cqV0eoSLBIMBtXS3CRPzjrFeVIdrd384QnVH9vtaE0AwPUVtYDy0EMP6e6779bcuXMjAkpVVZUCgYCys7PD29xut2bPnq2ysrJuA0ooFFIoFAqvNzQ0RKvbuM7iPKly+25xtGZbbbWj9QAA119UAsrevXtVXl6uEydOdNkXCAQkSV6vN2K71+vV+fPnu61XWFioTZs2Od9RAABgJcd/xVNdXa3vf//7+ulPf6qRI0f22M7lckWsG2O6bOuUl5en+vr68FJdzb+QAQCIZY5fQSkvL1dNTY1mzJgR3tbe3q6jR49q27ZtqqyslHT5SsrYsWPDbWpqarpcVenkdrvldrud7ioAALCU41dQ5syZo9OnT+vUqVPh5bbbbtP999+vU6dO6fOf/7x8Pp9KS0vDr2ltbdWRI0eUmZnpdHcAAMAg5PgVlMTERE2dOjVi26hRo+TxeMLbc3NzVVBQoIyMDGVkZKigoEAJCQlasmSJ090BAACDUNQf1Nad9evXq7m5WatWrQo/qO3gwYM8AwUAAEi6TgHl9ddfj1h3uVzKz89Xfn7+9Xh7AAAwyDAXDwAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6wzIz4wxuPj9fgWDQUdrVlRUOFoPABBbCCjold/v18RJk9XS3DTQXQEADCEEFPQqGAyqpblJnpx1ivOkOla3+cMTqj+227F6AIDYQkDBVYnzpMrtu8Wxem21zEgNAOgZN8kCAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHnxkDAKIiWk+MTk5OVlpaWlRqwx4EFACAo9ob6ySXS0uXLo1K/ZHxCao8V0FIiXEEFACAozpCjZIxjj+BWrr8kMfaV59RMBgkoMQ4AgoAICqcfgI1hhZukgUAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1iGgAAAA6xBQAACAdQgoAADAOgQUAABgHQIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1hg90BwAA6K+KigrHayYnJystLc3xurg2jgeUwsJC7du3T+fOnVN8fLwyMzP11FNPaeLEieE2xhht2rRJO3bsUF1dnWbOnKkf//jHmjJlitPdAQDEkPbGOsnl0tKlSx2vPTI+QZXnKggplnA8oBw5ckQPPfSQbr/9dv3hD3/Qxo0blZ2drd/85jcaNWqUJGnLli3aunWrSkpKNGHCBD3xxBOaN2+eKisrlZiY6HSXAAAxoiPUKBkjT846xXlSHavbVlut2lefUTAYJKBYwvGA8stf/jJifefOnbr55ptVXl6uL3/5yzLGqKioSBs3btSiRYskSbt27ZLX69WePXu0cuVKp7sEAIgxcZ5UuX23DHQ3EEVRv0m2vr5ekjRmzBhJUlVVlQKBgLKzs8Nt3G63Zs+erbKysmh3BwAADAJRvUnWGKO1a9fqzjvv1NSpUyVJgUBAkuT1eiPaer1enT9/vts6oVBIoVAovN7Q0BClHgMAABtE9QrK6tWr9etf/1o/+9nPuuxzuVwR68aYLts6FRYWKikpKbykpjr3vSMAALBP1ALKmjVrdODAAb322msaN25ceLvP55P0xyspnWpqarpcVemUl5en+vr68FJdXR2tbgMAAAs4HlCMMVq9erX27dunw4cPKz09PWJ/enq6fD6fSktLw9taW1t15MgRZWZmdlvT7XZr9OjREQsAAIhdjt+D8tBDD2nPnj3693//dyUmJoavlCQlJSk+Pl4ul0u5ubkqKChQRkaGMjIyVFBQoISEBC1ZssTp7gAAgEHI8YCyfft2SVJWVlbE9p07d+qb3/ymJGn9+vVqbm7WqlWrwg9qO3jwIM9AAQAAkqIQUIwxfbZxuVzKz89Xfn6+028PAABiAHPxxAi/369gMOh43WjMdwEAQF8IKDHA7/dr4qTJamluGuiuAADgCAJKDAgGg2ppbnJ8bgpJav7whOqP7Xa0JgAAfSGgxJBozE3RVsszZwAA11/U5+IBAADoLwIKAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADr8DPj64invQIAcHUIKNcJT3sFAODqEVCuE572CgDA1SOgXGc87RUAgL5xkywAALAOAQUAAFiHgAIAAKxDQAEAANYhoAAAAOsQUAAAgHUIKAAAwDoEFAAAYB0CCgAAsA4BBQAAWIeAAgAArENAAQAA1mGyQAAA/l9FRUVU6iYnJystLS0qtWMVAQUAMOS1N9ZJLpeWLl0alfoj4xNUea6CkNIPBBQAwJDXEWqUjJEnZ53iPKmO1m6rrVbtq88oGAwSUPqBgAIAwP+L86TK7btloLsBcZMsAACwEAEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1+JlxN/x+v4LBoKM1o/V0QgDA4BCNvwdi+Qm1BJQr+P1+TZw0WS3NTQPdFQBADIjmU2pj+Qm1BJQrBINBtTQ3Of40weYPT6j+2G7H6gEABodoPaW28wm1x44d0+TJkx2r22mgr84QUHrg9NME22qrHasFABh8nP57JdbnDxrQgPLcc8/p6aef1sWLFzVlyhQVFRXpr/7qrwaySwAADAqxPn/QgAWUl156Sbm5uXruued0xx136Pnnn9eCBQv0m9/8Jia/SwMAIBpidf6gAfuZ8datW7VixQp95zvf0eTJk1VUVKTU1FRt3759oLoEAAAsMSBXUFpbW1VeXq4NGzZEbM/OzlZZWVmX9qFQSKFQKLxeX18vSWpoaHC8b42NjZffM/C+OlpbHKvbeQ+K03UHa+1B2efffSRJKi8vDx8nTqmsrJTEOEezbjRrR7XPHHfXpTZ9vqL2/x93jY2Njv5d21nLGNN3YzMAPv74YyPJvPnmmxHbn3zySTNhwoQu7R977DEjiYWFhYWFhSUGlurq6j6zwoDeJOtyuSLWjTFdtklSXl6e1q5dG17v6OjQ7373O3k8nm7bDwYNDQ1KTU1VdXW1Ro8ePdDdGVCMxWWMw2WMwx8xFpcxDpfFwjgYY3Tp0iWlpKT02XZAAkpycrKGDRumQCAQsb2mpkZer7dLe7fbLbfbHbHtxhtvjGYXr5vRo0cP2gPNaYzFZYzDZYzDHzEWlzEOlw32cUhKSrqqdgNyk+yIESM0Y8YMlZaWRmwvLS1VZmbmQHQJAABYZMC+4lm7dq2WLVum2267TbNmzdKOHTvk9/v13e9+d6C6BAAALDFgAeXrX/+6amtr9fjjj+vixYuaOnWq/uM//kPjx48fqC5dV263W4899liXr66GIsbiMsbhMsbhjxiLyxiHy4baOLiMuZrf+gAAAFw/A/agNgAAgJ4QUAAAgHUIKAAAwDoEFAAAYB0CigMKCwt1++23KzExUTfffLP+5m/+JjzHRSdjjPLz85WSkqL4+HhlZWXp7NmzfdZ++eWXdeutt8rtduvWW2/V/v37o/Ux/mR9jUNbW5seeeQRTZs2TaNGjVJKSooeeOABXbhwode6JSUlcrlcXZaWFmfnnnDS1RwT3/zmN7t8pr/8y7/ss3YsHROSuv2zdblcevrpp3usO9iOie3bt+sLX/hC+AFbs2bN0i9+8Yvw/qFwfujU21gMpXNEX8fEUDg/9MmBqXWGvPnz55udO3eaM2fOmFOnTpm7777bpKWlmcbGxnCbzZs3m8TERPPyyy+b06dPm69//etm7NixpqGhoce6ZWVlZtiwYaagoMBUVFSYgoICM3z4cPPf//3f1+Nj9Vtf4/D73//ezJ0717z00kvm3Llz5q233jIzZ840M2bM6LXuzp07zejRo83FixcjFptdzTGxfPly89WvfjXiM9XW1vZaN9aOCWNMlz/Xf/3XfzUul8t88MEHPdYdbMfEgQMHzM9//nNTWVlpKisrzaOPPmri4uLMmTNnjDFD4/zQqbexGErniL6OiaFwfugLASUKampqjCRz5MgRY4wxHR0dxufzmc2bN4fbtLS0mKSkJPOTn/ykxzqLFy82X/3qVyO2zZ8/39x3333R6bjDrhyH7rz99ttGkjl//nyPbXbu3GmSkpKi0MPrp7uxWL58ubn33nv7VWcoHBP33nuv+cpXvtJrnVg4Jm666SbzL//yL0P2/PBpnWPRnaFyjjAmchyG4vnhSnzFEwX19fWSpDFjxkiSqqqqFAgElJ2dHW7jdrs1e/ZslZWV9VjnrbfeiniNJM2fP7/X19jkynHoqY3L5epzbqXGxkaNHz9e48aNU05Ojt555x0nuxp1PY3F66+/rptvvlkTJkzQgw8+qJqaml7rxPox8b//+7/6+c9/rhUrVvRZa7AeE+3t7dq7d68++eQTzZo1a8ieH6SuY9GdoXCO6Gkchtr54UoEFIcZY7R27Vrdeeedmjp1qiSFJ0W8ciJEr9fbZcLETwsEAv1+jS26G4crtbS0aMOGDVqyZEmvE19NmjRJJSUlOnDggH72s59p5MiRuuOOO/Tee+9Fq/uO6mksFixYoJ/+9Kc6fPiwnnnmGR0/flxf+cpXFAqFeqwV68fErl27lJiYqEWLFvVaazAeE6dPn9af/dmfye1267vf/a7279+vW2+9dUieH3oaiyvF+jmit3EYaueHbg3sBZzYs2rVKjN+/HhTXV0d3vbmm28aSebChQsRbb/zne+Y+fPn91grLi7O7NmzJ2Lb7t27jdvtdrbTUdDdOHxaa2uruffee82XvvQlU19f36/a7e3tZvr06WbNmjVOdDXq+hqLThcuXDBxcXHm5Zdf7rFNLB8TxhgzceJEs3r16n7XHgzHRCgUMu+99545fvy42bBhg0lOTjZnz54dkueHnsbi04bCOeJqxqFTrJ8fujNgc/HEojVr1ujAgQM6evSoxo0bF97u8/kkXU63Y8eODW+vqanpknY/zefzdUm+fb3GBj2NQ6e2tjYtXrxYVVVVOnz4cL+nDb/hhht0++23W/+vI6nvsfi0sWPHavz48b1+rlg9JiTp2LFjqqys1EsvvdTv+oPhmBgxYoRuueUWSdJtt92m48eP60c/+pEeeeQRSUPn/CD1PBbPP/+8pKFzjuhrHD4tls8PPeErHgcYY7R69Wrt27dPhw8fVnp6esT+9PR0+Xw+lZaWhre1trbqyJEjyszM7LHurFmzIl4jSQcPHuz1NQOpr3GQ/njiee+993To0CF5PJ5rep9Tp05FnMxtczVjcaXa2lpVV1f3+rli8Zjo9MILL2jGjBmaPn36Nb2P7cfElYwxCoVCQ+b80JvOsZCGzjmiO58ehyvF4vmhTwN16SaW/N3f/Z1JSkoyr7/+esRPwpqamsJtNm/ebJKSksy+ffvM6dOnzTe+8Y0uPyNctmyZ2bBhQ3j9zTffNMOGDTObN282FRUVZvPmzVb/ZKyvcWhrazMLFy4048aNM6dOnYpoEwqFwnWuHIf8/Hzzy1/+0nzwwQfmnXfeMd/61rfM8OHDza9+9avr/hmvVl9jcenSJbNu3TpTVlZmqqqqzGuvvWZmzZplPvvZzw6pY6JTfX29SUhIMNu3b++2zmA/JvLy8szRo0dNVVWV+fWvf20effRRc8MNN5iDBw8aY4bG+aFTb2MxlM4RvY3DUDk/9IWA4gBJ3S47d+4Mt+no6DCPPfaY8fl8xu12my9/+cvm9OnTEXVmz55tli9fHrHt3/7t38zEiRNNXFycmTRpUq/fPw60vsahqqqqxzavvfZauM6V45Cbm2vS0tLMiBEjzGc+8xmTnZ1tysrKru+H66e+xqKpqclkZ2ebz3zmMyYuLs6kpaWZ5cuXG7/fH1En1o+JTs8//7yJj483v//977utM9iPiW9/+9tm/Pjx4f7OmTMnHE6MGRrnh069jcVQOkf0Ng5D5fzQF5cxxkT3Gg0AAED/cA8KAACwDgEFAABYh4ACAACsQ0ABAADWIaAAAADrEFAAAIB1CCgAAMA6BBQAAGAdAgoAALAOAQUAAFiHgAIAAKxDQAEAANb5P8nmxOCg2Q1DAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "28.0 139\n", + "27.0 125\n", + "26.0 120\n", + "29.0 115\n", + "25.0 98\n", + "30.0 90\n", + "24.0 78\n", + "31.0 61\n", + "23.0 41\n", + "22.0 35\n", + "32.0 31\n", + "33.0 22\n", + "21.0 17\n", + "20.0 13\n", + "34.0 7\n", + "19.0 3\n", + "35.0 3\n", + "36.0 2\n", + "Name: observation, dtype: int64\n" + ] + } + ], + "source": [ + "# your code here\n", + "data = pd.read_csv('C:\\\\Users\\\\farma\\Desktop\\\\iron hack\\\\week4\\\\lab\\\\Descriptive-Stats\\\\data\\\\ages_population2.csv')\n", + "freq = data[\"observation\"].value_counts()\n", + "plt.hist(data[\"observation\"], bins=20, edgecolor=\"black\")\n", + "\n", + "plt.show()\n", + "print(freq)" ] }, { @@ -338,8 +666,8 @@ "outputs": [], "source": [ "\"\"\"\n", - "your comments here\n", - "\"\"\"" + "The difference with the frequency distribution in step 1 is that it shows a wider range of ages and a more gradual decrease \n", + "in frequency as age increases,indicating a more diverse population in terms of age.\"\"\"" ] }, { @@ -351,11 +679,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 68, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "27.155\n", + "2.968328654310368\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "freq = data['observation'].value_counts().sort_index()\n", + "mean = np.sum(freq.index * freq.values) / np.sum(freq.values)\n", + "std = np.sqrt(np.sum((freq.index - mean)**2 * freq.values) / np.sum(freq.values))\n", + "print(mean)\n", + "print(std)\n", + "\n" ] }, { @@ -365,7 +708,7 @@ "outputs": [], "source": [ "\"\"\"\n", - "your comments here\n", + " the data in the second population is more concentrated around the mean, and there is less variability in the data compared to the first population\n", "\"\"\"" ] }, @@ -381,11 +724,46 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "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" + ] + } + ], + "source": [ + "# your code here\n", + "data = pd.read_csv('C:\\\\Users\\\\farma\\Desktop\\\\iron hack\\\\week4\\\\lab\\\\Descriptive-Stats\\\\data\\\\ages_population3.csv')\n", + "freq = data['observation'].value_counts().sort_index()\n", + "plt.hist(data[\"observation\"], bins=20, edgecolor=\"black\")\n", + "\n", + "plt.show()\n", + "print(freq)" ] }, { @@ -397,11 +775,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 73, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "41.989\n", + "16.136631587788077\n" + ] + } + ], "source": [ - "# your code here" + "# your code here\n", + "mean = np.sum(freq.index * freq.values) / np.sum(freq.values)\n", + "std = np.sqrt(np.sum((freq.index - mean)**2 * freq.values) / np.sum(freq.values))\n", + "print(mean)\n", + "print(std)" ] }, { @@ -411,8 +802,8 @@ "outputs": [], "source": [ "\"\"\"\n", - "your comments here\n", - "\"\"\"" + "Compared to the first distribution, the third distribution has a higher mean and standard deviation\n", + "indicating that the data is more spread out and has a greater range. \"\"\"" ] }, { @@ -500,9 +891,9 @@ ], "metadata": { "kernelspec": { - "display_name": "ironhack-3.7", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "ironhack-3.7" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -514,7 +905,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.9.13" } }, "nbformat": 4,