From a6201a502158ac983bdf89076c60646cc0439940 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 23 Oct 2025 22:03:54 +0000 Subject: [PATCH] Refactor: Update notebooks and gitignore This commit updates several Jupyter notebooks and the gitignore file. It includes changes related to data normalization, separation, and visualization practices using Matplotlib and Seaborn. Co-authored-by: r.hortamani --- .gitignore | 5 +- ...tion-and-Data-Separation -checkpoint.ipynb | 311 ---- .../Untitled-checkpoint.ipynb | 6 - Matplotlib/Bar_Chart_Practice.ipynb | 496 +----- Matplotlib/Histogram_Practice.ipynb | 293 +--- Matplotlib/bar_chart.ipynb | 573 +------ Matplotlib/matplotlib.ipynb | 830 +--------- ...n Normalization-and-Data-Separation .ipynb | 312 +--- ...tatistics from Stock Data-checkpoint.ipynb | 1052 ------------ ...tatistics-from-Stock-Data-checkpoint.ipynb | 1443 ---------------- Pandas/Statistics-from-Stock-Data.ipynb | 1444 +---------------- Pandas/output_28_0.png | Bin 16134 -> 15425 bytes scripts/clean_ipynb.py | 81 + 13 files changed, 91 insertions(+), 6755 deletions(-) delete mode 100644 .ipynb_checkpoints/Mean Normalization-and-Data-Separation -checkpoint.ipynb delete mode 100644 Matplotlib/.ipynb_checkpoints/Untitled-checkpoint.ipynb delete mode 100644 Pandas/.ipynb_checkpoints/Statistics from Stock Data-checkpoint.ipynb delete mode 100644 Pandas/.ipynb_checkpoints/Statistics-from-Stock-Data-checkpoint.ipynb create mode 100644 scripts/clean_ipynb.py diff --git a/.gitignore b/.gitignore index 16f2dc5..352c22d 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,4 @@ -*.csv \ No newline at end of file +*.csv +# Ignore Jupyter checkpoints +.ipynb_checkpoints/ +**/.ipynb_checkpoints/ diff --git a/.ipynb_checkpoints/Mean Normalization-and-Data-Separation -checkpoint.ipynb b/.ipynb_checkpoints/Mean Normalization-and-Data-Separation -checkpoint.ipynb deleted file mode 100644 index 57fde73..0000000 --- a/.ipynb_checkpoints/Mean Normalization-and-Data-Separation -checkpoint.ipynb +++ /dev/null @@ -1,311 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Mean Normalization\n", - "\n", - "In machine learning we use large amounts of data to train our models. Some machine learning algorithms may require that the data is *normalized* in order to work correctly. The idea of normalization, also known as *feature scaling*, is to ensure that all the data is on a similar scale, *i.e.* that all the data takes on a similar range of values. For example, we might have a dataset that has values between 0 and 5,000. By normalizing the data we can make the range of values be between 0 and 1.\n", - "\n", - "In this lab, you will be performing a different kind of feature scaling known as *mean normalization*. Mean normalization will scale the data, but instead of making the values be between 0 and 1, it will distribute the values evenly in some small interval around zero. For example, if we have a dataset that has values between 0 and 5,000, after mean normalization the range of values will be distributed in some small range around 0, for example between -3 to 3. Because the range of values are distributed evenly around zero, this guarantees that the average (mean) of all elements will be zero. Therefore, when you perform *mean normalization* your data will not only be scaled but it will also have an average of zero. \n", - "\n", - "# To Do:\n", - "\n", - "You will start by importing NumPy and creating a rank 2 ndarray of random integers between 0 and 5,000 (inclusive) with 1000 rows and 20 columns. This array will simulate a dataset with a wide range of values. Fill in the code below" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1000, 20)\n" - ] - } - ], - "source": [ - "# import NumPy into Python\n", - "import numpy as np\n", - "\n", - "# Create a 1000 x 20 ndarray with random integers in the half-open interval [0, 5001).\n", - "X = np.random.randint(0, 5001, size=(1000,20))\n", - "\n", - "# print the shape of X\n", - "print(X.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that you created the array we will mean normalize it. We will perform mean normalization using the following equation:\n", - "\n", - "$\\mbox{Norm_Col}_i = \\frac{\\mbox{Col}_i - \\mu_i}{\\sigma_i}$\n", - "\n", - "where $\\mbox{Col}_i$ is the $i$th column of $X$, $\\mu_i$ is average of the values in the $i$th column of $X$, and $\\sigma_i$ is the standard deviation of the values in the $i$th column of $X$. In other words, mean normalization is performed by subtracting from each column of $X$ the average of its values, and then by dividing by the standard deviation of its values. In the space below, you will first calculate the average and standard deviation of each column of $X$. " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Average of the values in each column of X\n", - "ave_cols = X.mean(axis=0)\n", - "\n", - "# Standard Deviation of the values in each column of X\n", - "std_cols = X.std(axis=0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you have done the above calculations correctly, then `ave_cols` and `std_cols`, should both be vectors with shape `(20,)` since $X$ has 20 columns. You can verify this by filling the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(20,)\n", - "(20,)\n" - ] - } - ], - "source": [ - "# Print the shape of ave_cols\n", - "print(ave_cols.shape)\n", - "\n", - "# Print the shape of std_cols\n", - "print(std_cols.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can now take advantage of Broadcasting to calculate the mean normalized version of $X$ in just one line of code using the equation above. Fill in the code below" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1000, 20)\n" - ] - } - ], - "source": [ - "# Mean normalize X\n", - "X_norm = (X - ave_cols) / std_cols\n", - "print(X_norm.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you have performed the mean normalization correctly, then the average of all the elements in $X_{\\tiny{\\mbox{norm}}}$ should be close to zero, and they should be evenly distributed in some small interval around zero. You can verify this by filing the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-1.54543045028e-17\n", - "-1.72906934918\n" - ] - } - ], - "source": [ - "# Print the average of all the values of X_norm\n", - "print(X_norm.mean())\n", - "\n", - "# Print the average of the minimum value in each column of X_norm\n", - "print(X_norm.min(axis=0).mean())\n", - "\n", - "# Print the average of the maximum value in each column of X_norm\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You should note that since $X$ was created using random integers, the above values will vary. \n", - "\n", - "# Data Separation\n", - "\n", - "After the data has been mean normalized, it is customary in machine learnig to split our dataset into three sets:\n", - "\n", - "1. A Training Set\n", - "2. A Cross Validation Set\n", - "3. A Test Set\n", - "\n", - "The dataset is usually divided such that the Training Set contains 60% of the data, the Cross Validation Set contains 20% of the data, and the Test Set contains 20% of the data. \n", - "\n", - "In this part of the lab you will separate `X_norm` into a Training Set, Cross Validation Set, and a Test Set. Each data set will contain rows of `X_norm` chosen at random, making sure that we don't pick the same row twice. This will guarantee that all the rows of `X_norm` are chosen and randomly distributed among the three new sets.\n", - "\n", - "You will start by creating a rank 1 ndarray that contains a random permutation of the row indices of `X_norm`. You can do this by using the `np.random.permutation()` function. The `np.random.permutation(N)` function creates a random permutation of integers from 0 to `N - 1`. Let's see an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 1, 3, 4, 2])" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We create a random permutation of integers 0 to 4\n", - "np.random.permutation(5)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# To Do\n", - "\n", - "In the space below create a rank 1 ndarray that contains a random permutation of the row indices of `X_norm`. You can do this in one line of code by extracting the number of rows of `X_norm` using the `shape` attribute and then passing it to the `np.random.permutation()` function. Remember the `shape` attribute returns a tuple with two numbers in the form `(rows,columns)`." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1000,)\n" - ] - } - ], - "source": [ - "# Create a rank 1 ndarray that contains a random permutation of the row indices of `X_norm`\n", - "row_indices = np.random.permutation(X_norm.shape[0])\n", - "print(row_indices.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now you can create the three datasets using the `row_indices` ndarray to select the rows that will go into each dataset. Rememeber that the Training Set contains 60% of the data, the Cross Validation Set contains 20% of the data, and the Test Set contains 20% of the data. Each set requires just one line of code to create. Fill in the code below" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "# Make any necessary calculations.\n", - "# You can save your calculations into variables to use later.\n", - "\n", - "\n", - "# Create a Training Set\n", - "X_train = X[row_indices[:600], :]\n", - "\n", - "# Create a Cross Validation Set\n", - "X_crossVal = X[row_indices[600:800], :]\n", - "\n", - "# Create a Test Set\n", - "X_test = X[row_indices[800:], :]\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you performed the above calculations correctly, then `X_tain` should have 600 rows and 20 columns, `X_crossVal` should have 200 rows and 20 columns, and `X_test` should have 200 rows and 20 columns. You can verify this by filling the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(600, 20)\n", - "(200, 20)\n", - "(200, 20)\n" - ] - } - ], - "source": [ - "# Print the shape of X_train\n", - "print(X_train.shape)\n", - "\n", - "# Print the shape of X_crossVal\n", - "print(X_crossVal.shape)\n", - "\n", - "# Print the shape of X_test\n", - "print(X_test.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [default]", - "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.6.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Matplotlib/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/Matplotlib/.ipynb_checkpoints/Untitled-checkpoint.ipynb deleted file mode 100644 index 2fd6442..0000000 --- a/Matplotlib/.ipynb_checkpoints/Untitled-checkpoint.ipynb +++ /dev/null @@ -1,6 +0,0 @@ -{ - "cells": [], - "metadata": {}, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Matplotlib/Bar_Chart_Practice.ipynb b/Matplotlib/Bar_Chart_Practice.ipynb index 959e612..d0147a5 100644 --- a/Matplotlib/Bar_Chart_Practice.ipynb +++ b/Matplotlib/Bar_Chart_Practice.ipynb @@ -1,495 +1 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In workspaces like this one, you will be able to practice visualization techniques you've seen in the course materials. In this particular workspace, you'll practice creating single-variable plots for categorical data." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# prerequisite package imports\n", - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sb\n", - "\n", - "%matplotlib inline\n", - "\n", - "# solution script imports\n", - "from solutions_univ import bar_chart_solution_1, bar_chart_solution_2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In this workspace, you'll be working with this dataset comprised of attributes of creatures in the video game series Pokémon. The data was assembled from the database of information found in [this GitHub repository](https://github.com/veekun/pokedex/tree/master/pokedex/data/csv)." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idspeciesgeneration_idheightweightbase_experiencetype_1type_2hpattackdefensespeedspecial-attackspecial-defense
01bulbasaur10.76.964grasspoison454949456565
12ivysaur11.013.0142grasspoison606263608080
23venusaur12.0100.0236grasspoison80828380100100
34charmander10.68.562fireNaN395243656050
45charmeleon11.119.0142fireNaN586458808065
\n", - "
" - ], - "text/plain": [ - " id species generation_id height weight base_experience type_1 \\\n", - "0 1 bulbasaur 1 0.7 6.9 64 grass \n", - "1 2 ivysaur 1 1.0 13.0 142 grass \n", - "2 3 venusaur 1 2.0 100.0 236 grass \n", - "3 4 charmander 1 0.6 8.5 62 fire \n", - "4 5 charmeleon 1 1.1 19.0 142 fire \n", - "\n", - " type_2 hp attack defense speed special-attack special-defense \n", - "0 poison 45 49 49 45 65 65 \n", - "1 poison 60 62 63 60 80 80 \n", - "2 poison 80 82 83 80 100 100 \n", - "3 NaN 39 52 43 65 60 50 \n", - "4 NaN 58 64 58 80 80 65 " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = pd.read_csv('./data/pokemon.csv')\n", - "df.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Task 1**: There have been quite a few Pokémon introduced over the series' history. How many were introduced in each generation? Create a _bar chart_ of these frequencies using the 'generation_id' column." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# YOUR CODE HERE\n", - "sb.countplot(data=df, x=df['generation_id'], color=sb.color_palette()[2])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Once you've created your chart, run the cell below to check the output from our solution. Your visualization does not need to be exactly the same as ours, but it should be able to come up with the same conclusions." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "I used seaborn's countplot function to generate this chart. I also added an additional argument so that each bar has the same color.\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAELCAYAAADDZxFQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAFP5JREFUeJzt3X+w3XV95/HnS6JSVAZsLogJbKgTsejQAreUSuuiWIUVCWvFgVHJKLvp7rJU1hWVujvsj3HW1m790SqzEZCwZaGIILRLLSzFotsCJvz+5ZIFhAiSsIiItjjge/8435Rj/IR7csk533tzn4+ZM/d8P9/v+Z7XzUzyyvd3qgpJkrb0gr4DSJLmJgtCktRkQUiSmiwISVKTBSFJarIgJElNFoQkqcmCkCQ1WRCSpKZFfQd4PhYvXlzLli3rO4YkzSvr1q17tKqmZlpuXhfEsmXLWLt2bd8xJGleSfLtUZYb2y6mJOck2Zjk9i3GT0nyrSR3JPn9ofHTk6zv5r11XLkkSaMZ5xbEucAfA+dtHkjyRmAFcEBVPZVkj258f+B44LXAK4H/leTVVfXMGPNJkp7D2LYgqupa4LEthv8l8ImqeqpbZmM3vgK4sKqeqqr7gPXAIePKJkma2aTPYno18BtJrk/y10l+pRtfAjw4tNyGbuxnJFmVZG2StZs2bRpzXElauCZdEIuA3YFDgdOAi5IESGPZ5oMqqmp1VU1X1fTU1IwH4SVJszTpgtgAXFIDNwA/ARZ343sPLbcUeGjC2SRJQyZdEF8B3gSQ5NXAi4BHgcuB45O8OMm+wHLghglnkyQNGdtZTEkuAA4HFifZAJwBnAOc0536+mNgZQ2eeXpHkouAO4GngZM9g0mS+pX5/Ezq6enp8kI5Sdo2SdZV1fRMy83rK6klPevg086beaGerPvkiX1H0Cx4sz5JUpMFIUlqsiAkSU0WhCSpyYKQJDXtcGcxzdUzOTyLQ9J84xaEJKnJgpAkNVkQkqQmC0KS1GRBSJKaLAhJUpMFIUlqsiAkSU0WhCSpyYKQJDWNrSCSnJNkY/d40S3nfShJJVncTSfJZ5OsT3JrkoPGlUuSNJpxbkGcCxy55WCSvYHfBB4YGj4KWN69VgFnjjGXJGkEYyuIqroWeKwx61PAh4Hhh2GvAM6rgeuA3ZLsNa5skqSZTfQYRJJjgO9U1S1bzFoCPDg0vaEbkyT1ZGK3+06yC/Ax4C2t2Y2xaoyRZBWD3VDss88+2y2fJOmnTXIL4lXAvsAtSe4HlgI3JnkFgy2GvYeWXQo81FpJVa2uqumqmp6amhpzZElauCZWEFV1W1XtUVXLqmoZg1I4qKq+C1wOnNidzXQo8P2qenhS2SRJP2ucp7leAPwtsF+SDUlOeo7FrwDuBdYDXwD+1bhySZJGM7ZjEFV1wgzzlw29L+DkcWWRJG07r6SWJDVZEJKkpomd5qqF4eDTzus7QtO6T57YdwRp3nELQpLUZEFIkposCElSkwUhSWqyICRJTRaEJKnJgpAkNVkQkqQmC0KS1GRBSJKaLAhJUpMFIUlqsiAkSU0WhCSpyYKQJDWN85nU5yTZmOT2obFPJrk7ya1JLk2y29C805OsT/KtJG8dVy5J0mjGuQVxLnDkFmNXAa+rqgOA/wOcDpBkf+B44LXdZz6fZKcxZpMkzWBsBVFV1wKPbTF2ZVU93U1eByzt3q8ALqyqp6rqPmA9cMi4skmSZtbnMYj3A3/RvV8CPDg0b0M3JknqSS8FkeRjwNPA+ZuHGovVVj67KsnaJGs3bdo0roiStOBNvCCSrASOBt5dVZtLYAOw99BiS4GHWp+vqtVVNV1V01NTU+MNK0kL2EQLIsmRwEeAY6rqR0OzLgeOT/LiJPsCy4EbJplNkvTTFo1rxUkuAA4HFifZAJzB4KylFwNXJQG4rqr+RVXdkeQi4E4Gu55OrqpnxpVNkjSzsRVEVZ3QGD77OZb/OPDxceWRJG0br6SWJDVZEJKkJgtCktRkQUiSmiwISVKTBSFJarIgJElNFoQkqcmCkCQ1WRCSpCYLQpLUZEFIkprGdrM+ab45+LTz+o6wVes+eWLfEbQAuQUhSWqyICRJTRaEJKnJgpAkNY2tIJKck2RjktuHxl6e5Kok93Q/d+/Gk+SzSdYnuTXJQePKJUkazTi3IM4Fjtxi7KPA1VW1HLi6mwY4CljevVYBZ44xlyRpBGMriKq6Fnhsi+EVwJru/Rrg2KHx82rgOmC3JHuNK5skaWaTPgaxZ1U9DND93KMbXwI8OLTchm5MktSTuXKhXBpj1VwwWcVgNxT77LPPODP1Yq5erOWFWtLCM+ktiEc27zrqfm7sxjcAew8ttxR4qLWCqlpdVdNVNT01NTXWsJK0kE26IC4HVnbvVwKXDY2f2J3NdCjw/c27oiRJ/RjbLqYkFwCHA4uTbADOAD4BXJTkJOAB4Lhu8SuAfwKsB34EvG9cuSRJoxlbQVTVCVuZdURj2QJOHlcWSdK280pqSVKTBSFJarIgJElNFoQkqcmCkCQ1WRCSpCYLQpLUNFJBJLl6lDFJ0o7jOS+US7IzsAuDq6F359mb6u0KvHLM2SRJPZrpSurfBk5lUAbreLYgngA+N8ZckqSePWdBVNVngM8kOaWq/mhCmSRJc8BI92Kqqj9K8npg2fBnqmpuPrxAkvS8jVQQSf478CrgZuCZbrgAC0KSdlCj3s11Gti/u+uqJGkBGLUgbgdeAfgQH0lq2BEfFzxqQSwG7kxyA/DU5sGqOmbW3yxJmtNGLYj/MM4QkqS5Z9SzmP563EEkSXPLqLfa+EGSJ7rX3yd5JskTs/3SJP8myR1Jbk9yQZKdk+yb5Pok9yT50yQvmu36JUnP30gFUVUvq6pdu9fOwG8BfzybL0yyBPgdYLqqXgfsBBwP/B7wqapaDnwPOGk265ckbR+zuptrVX0FeNPz+N5FwM8lWcTgXk8Pd+u7uJu/Bjj2eaxfkvQ8jXqh3DuGJl/A4LqIWV0TUVXfSfIHwAPA3wFXMrjP0+NV9XS32AZgyWzWL0naPkY9i+ntQ++fBu4HVszmC7u7wq4A9gUeB74EHNVYtFlASVYBqwD22Wef2USQJI1g1LOY3rcdv/PNwH1VtQkgySXA64HdkizqtiKWAg9tJctqYDXA9PS0V3ZL0piMehbT0iSXJtmY5JEkX06ydJbf+QBwaJJdkgQ4ArgTuAZ4Z7fMSuCyWa5fkrQdjHqQ+ovA5QyeC7EE+LNubJtV1fUMDkbfCNzWZVgNfAT4YJL1wM8DZ89m/ZKk7WPUYxBTVTVcCOcmOXW2X1pVZwBnbDF8L3DIbNcpSdq+Rt2CeDTJe5Ls1L3eA/y/cQaTJPVr1IJ4P/Au4LsMrll4J7A9D1xLkuaYUXcx/WdgZVV9DyDJy4E/YFAckqQd0KhbEAdsLgeAqnoMOHA8kSRJc8GoBfGC7gI34B+2IEbd+pAkzUOj/iP/X4G/SXIxgyuc3wV8fGypJC04O+IT2ea7Ua+kPi/JWgY31Avwjqq6c6zJJEm9Gnk3UVcIloIkLRCzut23JGnHZ0FIkposCElSkwUhSWqyICRJTRaEJKnJgpAkNVkQkqQmC0KS1NRLQSTZLcnFSe5OcleSX0vy8iRXJbmn+7n7zGuSJI1LX1sQnwG+WlWvAX4JuAv4KHB1VS0Hru6mJUk9mXhBJNkVeANwNkBV/biqHgdWAGu6xdYAx046myTpWX1sQfwCsAn4YpKbkpyV5CXAnlX1MED3c48eskmSOn0UxCLgIODMqjoQ+CHbsDspyaoka5Os3bRp07gyStKC10dBbAA2VNX13fTFDArjkSR7AXQ/N7Y+XFWrq2q6qqanpqYmEliSFqKJF0RVfRd4MMl+3dARDJ4zcTmwshtbCVw26WySpGf19VzpU4Dzk7wIuBd4H4OyuijJScADwHE9ZZMk0VNBVNXNwHRj1hGTziJJavNKaklSkwUhSWqyICRJTRaEJKnJgpAkNVkQkqQmC0KS1GRBSJKaLAhJUpMFIUlqsiAkSU0WhCSpyYKQJDVZEJKkJgtCktRkQUiSmiwISVKTBSFJauqtIJLslOSmJH/eTe+b5Pok9yT50+551ZKknvS5BfEB4K6h6d8DPlVVy4HvASf1kkqSBPRUEEmWAm8DzuqmA7wJuLhbZA1wbB/ZJEkDfW1BfBr4MPCTbvrngcer6uluegOwpI9gkqSBiRdEkqOBjVW1bni4sWht5fOrkqxNsnbTpk1jyShJ6mcL4jDgmCT3Axcy2LX0aWC3JIu6ZZYCD7U+XFWrq2q6qqanpqYmkVeSFqSJF0RVnV5VS6tqGXA88FdV9W7gGuCd3WIrgcsmnU2S9Ky5dB3ER4APJlnP4JjE2T3nkaQFbdHMi4xPVX0N+Fr3/l7gkD7zSJKeNZe2ICRJc4gFIUlqsiAkSU0WhCSpyYKQJDVZEJKkJgtCktRkQUiSmiwISVKTBSFJarIgJElNFoQkqcmCkCQ1WRCSpCYLQpLUZEFIkposCElSkwUhSWqaeEEk2TvJNUnuSnJHkg904y9PclWSe7qfu086myTpWX1sQTwN/Nuq+kXgUODkJPsDHwWurqrlwNXdtCSpJxMviKp6uKpu7N7/ALgLWAKsANZ0i60Bjp10NknSs3o9BpFkGXAgcD2wZ1U9DIMSAfbYymdWJVmbZO2mTZsmFVWSFpzeCiLJS4EvA6dW1ROjfq6qVlfVdFVNT01NjS+gJC1wvRREkhcyKIfzq+qSbviRJHt18/cCNvaRTZI00MdZTAHOBu6qqj8cmnU5sLJ7vxK4bNLZJEnPWtTDdx4GvBe4LcnN3djvAp8ALkpyEvAAcFwP2SRJnYkXRFV9A8hWZh8xySySpK3zSmpJUpMFIUlqsiAkSU0WhCSpyYKQJDVZEJKkJgtCktRkQUiSmiwISVKTBSFJarIgJElNFoQkqcmCkCQ1WRCSpCYLQpLUZEFIkposCElS05wriCRHJvlWkvVJPtp3HklaqOZUQSTZCfgccBSwP3BCkv37TSVJC9OcKgjgEGB9Vd1bVT8GLgRW9JxJkhakuVYQS4AHh6Y3dGOSpAlLVfWd4R8kOQ54a1X9s276vcAhVXXK0DKrgFXd5H7At8YYaTHw6BjXP27m79d8zj+fs4P5Z/KPqmpqpoUWjTHAbGwA9h6aXgo8NLxAVa0GVk8iTJK1VTU9ie8aB/P3az7nn8/Zwfzby1zbxfRNYHmSfZO8CDgeuLznTJK0IM2pLYiqejrJvwb+EtgJOKeq7ug5liQtSHOqIACq6grgir5zdCayK2uMzN+v+Zx/PmcH828Xc+ogtSRp7phrxyAkSXOEBdGQ5JwkG5Pc3neW2Uiyd5JrktyV5I4kH+g706iS7JzkhiS3dNn/Y9+ZZiPJTkluSvLnfWfZVknuT3JbkpuTrO07z7ZKsluSi5Pc3f0d+LW+M40qyX7dn/vm1xNJTu0tj7uYflaSNwBPAudV1ev6zrOtkuwF7FVVNyZ5GbAOOLaq7uw52oySBHhJVT2Z5IXAN4APVNV1PUfbJkk+CEwDu1bV0X3n2RZJ7gemq2peXkeQZA3w9ao6qzsbcpeqerzvXNuqu/XQd4Bfrapv95HBLYiGqroWeKzvHLNVVQ9X1Y3d+x8AdzFPrkivgSe7yRd2r3n1v5gkS4G3AWf1nWWhSbIr8AbgbICq+vF8LIfOEcD/7ascwILY4SVZBhwIXN9vktF1u2duBjYCV1XVvMne+TTwYeAnfQeZpQKuTLKuu3PBfPILwCbgi90uvrOSvKTvULN0PHBBnwEsiB1YkpcCXwZOraon+s4zqqp6pqp+mcGV9IckmTe7+ZIcDWysqnV9Z3keDquqgxjcVfnkbpfrfLEIOAg4s6oOBH4IzLvHBnS7xo4BvtRnDgtiB9Xtv/8ycH5VXdJ3ntnodg18DTiy5yjb4jDgmG4//oXAm5L8Sb+Rtk1VPdT93AhcyuAuy/PFBmDD0FbnxQwKY745Crixqh7pM4QFsQPqDvSeDdxVVX/Yd55tkWQqyW7d+58D3gzc3W+q0VXV6VW1tKqWMdhF8FdV9Z6eY40syUu6Exvods28BZg3Z/NV1XeBB5Ps1w0dAcz5kzMaTqDn3UswB6+knguSXAAcDixOsgE4o6rO7jfVNjkMeC9wW7cvH+B3u6vU57q9gDXdGRwvAC6qqnl3qug8tidw6eD/GCwC/kdVfbXfSNvsFOD8bjfNvcD7es6zTZLsAvwm8Nu9Z/E0V0lSi7uYJElNFoQkqcmCkCQ1WRCSpCYLQpLUZEFIkposCGmMkpzande+efqKzRcCbqf1/6ckb26MHz4fbzWuucXrIKTnobtqPVXVvDFfX7fOTnI48KH5dqtxzS1uQWiHlOTfdw+MuSrJBUk+lORVSb7a3aX060le0y17bpLPJvmbJPcmeefQek5L8s0kt25+eFGSZd2DaD4P3AjsneTMJGuHH3KU5HeAVwLXJLmmG7s/yeLu/QeT3N69Tt1i3V/o1nVld8uRrf2e527Om+TI7nf+BvCOMfyxaoGxILTDSTIN/BaD25y/g8GDe2DwIPhTqupg4EPA54c+thfw68DRwCe69bwFWM7gZnW/DBw8dGfT/Rg8UOrA7n79H6uqaeAA4B8nOaCqPgs8BLyxqt64RcaDGdwC4leBQ4F/nuTAbvZy4HNV9Vrg8e53mel33hn4AvB24DeAV8z4ByXNwHsxaUf068BlVfV3AEn+DNgZeD3wpe4+QwAvHvrMV7rdRHcm2bMbe0v3uqmbfimDf7wfAL69xVPu3tU9O2ERg7LZH7h1hoyXVtUPu4yXMPiH/XLgvqrafA+tdcCyEX7n13Sfu6db358A8+1ZDppjLAjtiNIYewHwePeciZanGp8P8F+q6r/91MoHD2H64dD0vgy2SH6lqr6X5FwGhbStGVtZngG2uotpCx5Q1HblLibtiL4BvD3Jzt1Dk94G/Ai4L8lxMDi4nOSXZljPXwLv79ZBkiVJ9mgstyuDwvh+t/Vx1NC8HwAva3zmWuDYJLt0t9X+p8DXR/8Vf8bdwL5JXtVNn/A81iUBbkFoB1RV30xyOXAL8G1gLfB94N3AmUn+HYNnXV/YLbO19VyZ5BeBv+12Sz0JvIfB/+qHl7slyU3AHQxuL/2/h2avBv4iycPDxyGq6sZuS+OGbuisqrqp2zqZze/8990urv+Z5FEGJTlvnsSnucnTXLVDSvLSqnqyuwbhWmBVVd3Ydy5pPnELQjuq1Un2Z3AsYI3lIG07tyCkeSDJ5xg8KXDYZ6rqi33k0cJgQUiSmjyLSZLUZEFIkposCElSkwUhSWqyICRJTf8fLlGV+VdjnM4AAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "bar_chart_solution_1()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Task 2**: Each Pokémon species has one or two 'types' that play a part in its offensive and defensive capabilities. How frequent is each type? The code below creates a new dataframe that puts all of the type counts in a single column." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "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", - "
idspeciestype_leveltype
01bulbasaurtype_1grass
12ivysaurtype_1grass
23venusaurtype_1grass
34charmandertype_1fire
45charmeleontype_1fire
\n", - "
" - ], - "text/plain": [ - " id species type_level type\n", - "0 1 bulbasaur type_1 grass\n", - "1 2 ivysaur type_1 grass\n", - "2 3 venusaur type_1 grass\n", - "3 4 charmander type_1 fire\n", - "4 5 charmeleon type_1 fire" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pkmn_types = df.melt(id_vars = ['id','species'], \n", - " value_vars = ['type_1', 'type_2'], \n", - " var_name = 'type_level', value_name = 'type').dropna()\n", - "pkmn_types.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Your task is to use this dataframe to create a _relative frequency_ plot of the proportion of Pokémon with each type, _sorted_ from most frequent to least. **Hint**: The sum across bars should be greater than 100%, since many Pokémon have two types. Keep this in mind when considering a denominator to compute relative frequencies." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5,0,'proportion')" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# YOUR CODE HERE\n", - "# base_color = sb.color_palette()[2]\n", - "# sb.countplot(data=pkmn_types, x='type', color=base_color)\n", - "\n", - "# n_points = pkmn_types.shape[0]\n", - "# max_count = pkmn_types['type'].value_counts().max()\n", - "# max_props = max_count / n_points\n", - "\n", - "# # generate tick mark location and names\n", - "# tick_props = np.arange(0, max_props, 0.02)\n", - "# tick_names = ['{:0.2f}'.format(v) for v in tick_props]\n", - "\n", - "\n", - "# plt.yticks(tick_props*n_points, tick_names)\n", - "# plt.ylabel('proportion')\n", - "# plt.xticks(rotation=90)\n", - "\n", - "# get order of bars by frequency\n", - "type_counts = pkmn_types['type'].value_counts()\n", - "type_order = type_counts.index\n", - "\n", - "# compute largest proportion\n", - "n_pokemon = pkmn_types['species'].unique().shape[0]\n", - "max_type_count = type_counts[0]\n", - "max_prop = max_type_count / n_pokemon\n", - "\n", - "# establish tick locations and create plot\n", - "base_color = sb.color_palette()[2]\n", - "tick_props = np.arange(0, max_prop, 0.02)\n", - "tick_names = ['{:0.2f}'.format(v) for v in tick_props]\n", - "\n", - "base_color = sb.color_palette()[0]\n", - "sb.countplot(data = pkmn_types, y = 'type', color = base_color, order = type_order)\n", - "plt.xticks(tick_props * n_pokemon, tick_names)\n", - "plt.xlabel('proportion')\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "I created a horizontal bar chart since there are a lot of Pokemon types. The unique() method was used to get the number of different Pokemon species. I also added an xlabel call to make sure it was clear the bar length represents a relative frequency.\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZwAAAEKCAYAAAAmfuNnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzt3XmYHWWZ/vHvbcIWAgSEEZAfBlRENlkCgoCACwNu4IArIosaERHRcR1RwdnAdUQcMTBsioBsCigIIoGERUhCEkA2JUFZrlEkYlhElvv3R709HJpeTqfPqVOd3J/rypXqqvet85xOOk+qTtVdsk1ERES3vaDXBURExLIhDSciImqRhhMREbVIw4mIiFqk4URERC3ScCIiohZpOBERUYs0nIiIqEUaTkRE1GJ8rwtokjXXXNOTJ0/udRkREWPK7NmzH7S91nDj0nBaTJ48mVmzZvW6jIiIMUXSPe2MS8Npcdu9f2abT5/e6zIiImo1+2vvr+V1xuxnOJKOkDSh13VERER7xmzDAY4ARtRwJI3rUi0RETGMnjccSZ+RdHhZ/pakX5Xl10v6oaTvSZol6VZJR5dthwPrAldKurKs213SdZLmSDpH0sSyfqGkL0maCbyjJ28yIiJ633CAq4Gdy/IUYKKk5YCdgBnAF2xPAbYAdpG0he3jgPuB3WzvJmlN4EjgDba3BmYBn2x5jb/Z3sn2Wf1fXNLU0tBmPfXY4q69yYiIZV0TGs5sYBtJqwBPANdRNZ6dqRrOOyXNAW4CNgU2GWAf25f110iaCxwAvKRl+9mDvbjtaban2J4yfsIqnXg/ERExgJ5fpWb7SUkLgYOAa4H5wG7AS4HHgU8B29peJOlUYMUBdiPgctvvGeRlHu103RERMTJNOMKB6rTap8rvM4BDgLnAqlTN4mFJLwL2bJmzGOg7JLke2FHSywAkTZC0UU21R0REG5rScGYA6wDX2f5f4G/ADNvzqE6l3QqcDFzTMmcacImkK23/CTgQOFPSfKoGtHGN9UdExDBku9c1NMaUKVOcpIGIiJGRNLtc3DWkphzhRETEUi4NJyIiatHzq9SaJFlqETGUujLHllbLzBGOpOmShj3HGBER3TEmGo6kHIlFRIxxtf1DLmkycAkwE3gNcB+wF/AK4ASqIM7fAQeXmzynU90IuiNwoaTNqW4E3ZgqReAgqkSBHYBf2z6wvM73gG2BlYBzbX+5ljcYERFDqvsI5+XAd21vCvwF2Ac4Hfis7S2Am4HWBjHJ9i62v1G+Xh14HfAJ4CLgW1RxN5tL2rKMeV722lAFJUstIqIedTecBbbnluXZVPE1k2xfVdadBry2ZXz/DLSLXN04dDPwv7Zvtv0M1Y2hk8uYdrLX/k+y1CIi6lH3ZyNPtCw/DUwaZnz/DLS++c/029czwHhJG9Be9lpERNSs1xcNPAwsktT3eIL9gauGGD+cobLXIiKih5pw9dcBwAnlcdF3U10MsERsz5PUl712N8/NXouIiB5KllqLZKlFRIxcstQiIqJR0nAiIqIWTfgMpzGSpRYx9iTfbOxoxBGOpMMl3SbpPknHDzP2K5LeUFdtERHRGU05wjmU6hLmXYAhP3iy/aVaKoqIiI7q+RGOpBOADYELqaJrkLSKpAWSlitfryppoaTlJJ0qad+yfqGkoyXNkXSzpI3L+rUkXV7Wf1/SPZLW7NFbjIgIGtBwbB8C3A/sBiwq6xYD04E3l2HvBs6z/eQAu3jQ9tbA96hSBqDKY/tVWX8BsH7X3kBERLSl5w1nCCfx7E2gBwGnDDLu/PL7bJ7NU9sJOAvA9qWURjaQhHdGRNSjsQ3H9jXAZEm7AONs3zLI0L5Mtad59jMpjeB1Et4ZEVGDxjac4nTgTAY/uhnMTOCdAJJ2p3w2FBERvdP0hnMGVbM4c4TzjgZ2L48p2BN4AMj5soiIHmp0llq5Gm0v2/uPcN4KwNO2n5K0A/A921sONy9ZahERI9dullpT7sN5HknfoTo6edMSTF8f+LGkFwB/Bz7UydoiImLkGttwbH9sFHPvArbqYDkRETFKjW04vZAstYixIxlqY0/TLxqIiIilxJhpOJJyNBYRMYY15h9xSV8E9gP+ADxIlRzwFuBaYEfgQkl3AkcCywN/Bvaz/b/l5tBvl10ZeC0wETgbWJXqfX7E9oz63lFERLRqRMORNAXYh+qD/vHAHKqGAzDJ9i5l3OrA9rYt6YPAZ4B/pspQ+6jtayRNBP4GTAV+YfvfJY0DJtT6piIi4jka0XCoss9+avtxAEkXtWw7u2V5PeBsSetQHeUsKOuvAb4p6QzgfNv3SroROLkkTv/E9tyBXljSVKrmxPKrvLCT7ykiIlo05TOcobLPHm1Z/g5wvO3NgQ8DKwLYPgb4ILAScL2kjW1fTXVq7T7gB5IGvKQlWWoREfVoSsOZCbxV0orllNibBxm3GlUDATigb6Wkl9q+2faxwCxgY0kvAf5o+0Tgf4Ctu1d+REQMpxGn1GzfKOlCYB5wD1XTeHiAoUcB50i6D7ge2KCsP0LSblSJ0b8BLqF6hs6nJT0JPALkov2IiB5qTJaapIm2H5E0AbgamGp7Tp01JEstImLkxmKW2jRJm1B9LnNa3c0mIiK6qzENx/Z7e11DRER0T2MaThMkSy1icMkui9FqylVqIyJpV0kXD7LtpHJqLiIiGmSpO8Kx/cFe1xAREc/X1SMcSZMl3S7pNEnzJZ0raYKkYyT9pqz7uqRVJC0oqQBIWlXSQknLSXqZpF9KmidpjqSXlt1PLPu7XdIZklTmTi9ROUjao8yZJ+mKbr7XiIgYWh1HOK8APlByzk4GDgPeDmxcMtEm2V4saTrVDZ8/obqH5jzbT5a4mmNsXyBpRaom+f+octc2Be6nirbZkeoGUgAkrQWcCLzW9gJJa9TwXiMiYhB1fIbzB9vXlOUfUsXN/A04SdI/AY+VbScBB5Xlg4BTJK0CvNj2BQC2/2a7b/wNtu+1/QwwF5jc73W3B662vaDMfWig4iRNlTRL0qynHls82vcaERGDqKPh9L+z9ElgO+A8YG/gUoDSlCaXRw2Ms30LQ2esPdGy/DTPP1rTAK/9/OKSpRYRUYs6Gs76knYoy++hOhpZzfbPgSOALVvGng6cCZwCYPuvwL2S9gaQtEJJImjHdcAukjYoc3NKLSKih+poOLcBB0iaD6xBders4vL1VcAnWsaeAaxO1XT67A8cXsZfC6zdzova/hPVYwfOlzSP5z7mICIialbHRQPP2D6k37rtBhm7E3Cu7b/0rbB9F/C6fuPuBqa3jDmsZXnXluVLqII8IyKixxpzH46k7wB7Am/qVQ2vXO+FzMrd1BERXdHVhmN7IbBZm2M/1s1aIiKitxpzhNMEyVKLZUVy0aIXxkyWWkktuKXXdURExJIZMw0nIiLGtrHWcMYPkMu2UNKaAJKmlIgcJK0l6fKSpfZ9Sff0jYuIiPqNtYbzCmCa7S2AvwKHDjH2y8CvbG8NXACsX0N9ERExiLHWcPrnsu00xNidgLMAbF8KLBpoULLUIiLqMdYaTv9sNANP8ez7WLFl21A5bM/uIFlqERG1GGsNp38u20xgIbBNWbdPy9iZwDsBJO1OFZkTERE9MtYaTv9ctu8BRwPfljSDKjW6z9HA7pLmUCUYPADknFlERI+MmRs/S2rBJgNsmgFsNMD6h4F/tP1UOSrazfYTA4yLiIgajJmGswTWB34s6QXA34EPDTchWWoREd2z1DackjK9Va/riIiIylLbcJZEstSi15JxFkuzxl80IOkkSQN9dhMREWNI449wbH+w1zVERMTo1X6EU1Kfbx8gE+31km6SdLOkkyWtUMZPLxlp4ySdKumWMuYTZfuWkq4v+7pA0uot846VdIOkOyXtXPd7jYiIZ/XqlFr/TLRPAqcC77K9OdWR10f6zdkSeLHtzcqYU8r604HPln3dTJWh1me87e2AI/qtj4iImvWq4fTPRHs9sMD2nWXdacBr+825G9hQ0nck7QH8VdJqwCTbVw0y7/zy+2xg8kCFJEstIqIevWo4/TPRhp9gLwJeBUwHPgqc1Ma0vhs9n2aQz6uSpRYRUY9eNZz+mWi/BCZLellZtz9wVeuE8iybF9g+D/gisLXth4FFLZ/PPG9eREQ0Q6+uUuvLRPs+cBfwceB64BxJ44EbgRP6zXkxcEpJDgD4fPn9AOAESROoTrsd1O3iIyJi5HrVcJ6xfUi/dVcwQDKA7V1bvtx6gO1zge2Hmmf7QQb5DCciIurR+Ptw6pQstYiI7qm94ZTU583qft2IiOitHOG0SJZa1Cm5abGsaXyWWidI2lXSxb2uIyJiWdaYhlOuTouIiKVUbf/IS/oisB/wB+BBqrv/3wJcC+wIXCjpXOBkYC3gT8BBtn8v6VTgYtvnln09YnuipF2Bo8r+Niv7fJ9tlzSC/yrb5tT1PiMiYmC1NBxJU4B9qC57Hk/VAGaXzZNs71LGXQScbvs0SQcDxwF7D7P7rYBNgfuBa4AdJc0CTgReB/wWOLuz7ygiIkaqrlNqOwE/tf247cXARS3bWpvBDsCPyvIPyrzh3GD7XtvPAHOp7rfZmCqb7S7bpsprG1Cy1CIi6lFXw9EQ2x4dYltf5tpTlFolCVi+ZcwTLcutmWlt5bUlSy0ioh51NZyZwFslrShpIvDmQcZdC7y7LO9X5gEsBLYpy3sByw3zercDG0h6afn6PUtSdEREdE4tDcf2jcCFwDyqRwbMAh4eYOjhwEGS5lMFcX68rD8R2EXSDcCrGfqoCNt/A6YCP5M0E7inE+8jIiKWnKqPOGp4IWmi7UdKyObVwFTbjbp6bOW1N/DG+x/d6zJiGZEbP2NpIWm27SnDjavz3pdpkjYBVgROa1qzgWSpRUR0U20Nx/Z763qtiIhontzd3yJZalGnnFKLZU1jom3aJelwSbdJWiTpc72uJyIi2jPsEU6572U/YEPbX5G0PrC27Ru6Xt3ADgX2tL1goI2Sxtt+quaaIiJiGO0c4fw3VQJA370si4Hvdq2iIUg6AdiQKnftE5KOL+tPlfRNSVcCx0paWdLJkm6UdJOkvXpRb0REPKudz3BebXtrSTcB2F4kafnhJnWD7UNKKOduVMGfrTYC3mD7aUn/AfzK9sGSJgE3SPql7SHv34mIiO5p5wjnSUnjKFExktYCnulqVUvmHNtPl+Xdgc9JmgtMp7oUe/2BJiVLLSKiHu0c4RwHXAC8SNK/A/sCR3a1qiXTevQiYB/bdww3yfY0YBpUN352qbaIiGXesA3H9hmSZgOvL6v2tn1bd8satV8AH5P0sfJsnK1s39TroiIilmXtXhY9ARhXxq/UvXI65l+pAj7nS7qlfB0RET3UzmXRXwLeAZxHdarqFEnn2P63bhc3ENuTy+Kp5Re2D+w35nHgwzWWFRERwxg2vFPSbcBWJYEZSSsBc2y/sob6ajVlyhTPmjWr12VERIwp7YZ3tnNKbSHVVV59VgB+t4R1RUTEMqqdq9SeAG6VdDnVpdFvBGZKOg7A9uFdrK9WyVKLTkhGWsTA2mk4F5RffaZ3p5TOknQU8Ijtr/e6loiIaK/h/Bn4ue2e3uxZMt3U6zoiImLJtPMZzruBuyR9VVKtFwpImlySof8bmAPsL+lmSbdIOrZl3B6S5kiaJ+mKAfbzIUmXlAseIiKiB9q58fN9klalCu88RZKBU4AzbdeRBfMK4CDg34DrgW2ARcBlkvYGrgFOBF5re4GkNVonSzqMKupmb9tP1FBvREQMoK0bP23/leo+nLOAdYC3A3MkfayLtfW5x/b1wLbAdNt/Ko8fOAN4LbA9cHXf4wpsP9Qyd39gT6qYmwGbTbLUIiLqMWzDkfQ2SRcAv6K6e38723sCrwI+1eX64NmMNA1WIiVYdAC3AJOB9Qbbue1ptqfYnjJ+wipLXGRERAytnSOc/YBv2d7C9tds/1HSsbYfAw7ucn2tfg3sImnNkl79HuAq4LqyfgOAfqfUbqJKHLhQ0ro11hoREf2003Bebvvqfuv2BLD9vA/ou8X2A8DngSuBeVRpBz+1/SdgKnC+pHnA2f3mzaQ6EvuZpDXrqjciIp5r0IsGJH2E6nHOG0qa37JpFaoP6rvO9kJgs5avfwT8aIBxlwCX9Ft3VMvyL6gSpCMiokcGzVKTtBqwOvCfwOdaNi3u98H8UiNZahERI9dultqgRzi2HwYepvqsJCIiYlTaSRpYZiRLLfokDy2i89p9AFtERMSodK3hSDq8xNIskvS5YcbuKuniQbYdIWlCy9c/lzSp0/VGRER3dfOU2qHAnn0JAKNwBPBD4DEA228abWEREVG/rhzhSDoB2JDqhstPSDq+rH+ppOsl3SjpK5IeaZk2UdK5km6XdIYqhwPrAldKurLsY2G5+bMv2PNESbdKuqwvnFPStpLmS7pO0tck3dKN9xkREe3rSsOxfQhwP7AbVdBmn28D37a9bdneaiuqo5lNqJrVjraP69uP7d0GeKmXA9+1vSnwF2Cfsv4U4BDbOwBPD1VrstQiIupR90UDOwDnlOX+N3DeYPve8rybuVQZaMNZYHtuWZ4NTC6f76xi+9pBXuc5kqUWEVGPJl2l1prm/DTtP/66/5zBQj4jIqKH6m441/Psaa93tzlnMVWcTltsLwIWS9p+hK8TERFdVHfDOQL4pKQbqJ6r83Abc6YBl/RdNNCmDwDTJF1HdcTTzutEREQXDZql1pUXq+6nedy2Jb0beI/tvbrwOhNtP1KWPwesY/vjw81LllpExMiNOkutS7YBjpckqqvKuvU8nTdL+jzV+7sHOLBLrxMREW2q9Qin6VZeewNvvP/RvS4jOiiZaBHd1+4RTpOuUouIiKVYTxpOX1rAEszbVdJrhtj+tuFy2yIiojfG2uMJdgUeAa7tv0HSeNsXAhfWXVRERAyv60c4kt4n6QZJcyV9X9K4drZL2kPSHEnzJF0haTJwCPCJMnZnSadK+ma5ZPpYSQe25La9SNIFZf68oY6MIiKi+7racCS9EngXVS7allRpAPsNt13SWsCJwD62XwW8w/ZC4ATgW7a3tD2j7GYj4A22/7nfyx8HXFXmbw3cOkiNyVKLiKhBt0+pvZ7qUugbqyuhWQn4Yxvbtweu7nu0ge2HhniNc2wPFND5OuD9Zf7TDHLzp+1pVDeXsvLaG+SSvYiILul2wxFwmu3PP2eldOAw298GtPuP/6OjLTIiIrqv25/hXAHsK+kfACStIeklbWy/DthF0gZ968v4keSqXQF8pMwfJ2nVUb+biIhYYl1tOLZ/AxwJXCZpPnA5VYbakNtt/wmYCpwvaR5wdplyEfD2vosGhnn5jwO7SbqZ6tEFm3bwrUVExAglaaBFstQiIkYuSQMREdEoaTgREVGLsZY00FW33ftntvn06b0uI0YpgZ0RzTQmjnAkHVGepbOk80+VtG8na4qIiJEZEw2H6kmhS9xwIiKi9xrXcCStLOlnJf/sFklfBtYFrux7zLSk3SVdV7LWzpE0sazfRtJVkmZL+oWkdYZ6rYiIqE/jGg6wB3C/7VfZ3gz4L+B+YDfbu5XHGhxJlZ+2NTAL+KSk5YDvAPva3gY4Gfj34V4sWWoREfVo4kUDNwNfl3QscLHtGSVnrc/2wCbANWX98lTJBK8ANgMuL+vHAQ8M92LJUouIqEfjGo7tOyVtA7wJ+E9Jl/UbIuBy2+95zkppc+BW2zvUVGpERIxA406pSVoXeMz2D4GvUz1aoDVD7XpgR0kvK+MnSNoIuANYS9IOZf1ykhJnExHREI07wgE2B74m6RngSaoAzh2ASyQ9UD7HORA4U9IKZc6R5choX+A4SatRvbf/YpDn4ERERL2SpdYiWWoRESOXLLWIiGiUNJyIiKhFEz/D6ZlkqS0dkqUW0UyNPsKRdLik2ySdMcj2KZKOq7uuiIgYuaYf4RwK7Gl7wUAbbc+iShp4DknjbT/V7eIiIqJ9jT3CkXQCsCFwoaTPSrpW0k3l91eUMbtKurgsHyVpWrlR9HRJMyRt2bK/ayRt0ZM3ExERzT3CsX2IpD2A3YC/A9+w/ZSkNwD/AewzwLRtgJ1sPy7pAOBA4IhyY+gKtuf3nyBpKjAVYPlVXtidNxMREc09wulnNeAcSbcA3wIGSxC40PbjZfkc4C0l1PNg4NSBJtieZnuK7SnjJ6wy0JCIiOiAsdJw/hW4sqRHvxVYcZBxj/Yt2H4MuBzYC3gn8KNuFxkREYNr7Cm1flYD7ivLB45g3knARcAM2w91uqiIiGjfWDnC+SpVcvQ1VI8daIvt2cBfgVO6VVhERLRnqc5SK8nT04GNbT8z3PhkqUVEjNwyn6Um6f3Ar4EvtNNsIiKiu8bKZzgjZvt0IDk1ERENsdQ2nCWRLLWxLRlqEc02Zk6plSSBT3VrfEREdNeYaTgjISlHbhERDdPohiPpC5LukPRLoC8/7UOSbpQ0T9J5kiaU9adK+qakK4Fj++3nQ5IukbRS/e8iIiKgwQ1H0jbAu4GtgH8Cti2bzre9re1XAbcBH2iZthHwBtv/3LKfw6jSCfZuib2JiIiaNfnU087ABSWiBkkXlvWbSfo3YBIwEfhFy5xzbD/d8vX+wL1UzebJgV4k4Z0REfVo7BFOMdBdqacCh9neHDia5+aqPdpv7C3AZGC9QV8g4Z0REbVocsO5Gni7pJUkrUJ1WgxgFeCBkgK93zD7uAn4MNUzddbtXqkRETGcxjYc23OAs4G5wHnAjLLpi1QJApcDt7exn5nAp4CfSVqzO9VGRMRwluostZFKllpExMgt81lqERHRLGk4ERFRiyZfFl27ZKmNPclPixg7enKEk5yziIhlT2NOqSX/LCJi6VZbwxkkF226pP+QdBXwcUlvlfRrSTdJ+qWkF5Vxa0m6XNIcSd+XdE/fJc6SPinplvLriLJusqTbJJ0o6VZJlyVHLSKit2ppOEPkogFMsr2L7W8AM4HtbW8FnAV8poz5MvAr21sDFwDrt+z3IODVwPbAhyRtVea8HPiu7U2BvwD7dPEtRkTEMOo6jTVYLhpUN3f2WQ84W9I6wPLAgrJ+J+DtALYvlbSoZf0Fth8t+z2/vNaFwALbc8u42VQRN8+TLLWIiHrU+RnOYHeYtuaffQc4vuSkfZhnc9I0yNzB1gM80bL8NIM012SpRUTUo66GM1guWn+rAfeV5QNa1s8E3gkgaXdg9Zb97i1pgqSVqY6CZhAREY1TS8MZIhetv6OAcyTNAB5sWX80sLukOcCewAPA4rLfU4EbqPLVTrJ9UzfeQ0REjM6YyFKTtALwtO2nJO0AfM/2lp1+nWSpRUSMXLtZamPl3pf1gR9LegHwd+BDPa4nIiJGaEw0HNt3UV1SHRERY9SYaDh1SZZa8yU7LWLsaky0zUBKEsGw5wWH2cckSYd2qqaIiFgyjW44HTIJSMOJiOixxjQcSV+UdHvJTDuzJU36HZJukHSnpJ3L2BUlnSLp5pK7tltZv2kZO1fSfEkvB44BXlrWfa1Hby8iYpnXiM9wymmzfaguDBgPzKGKowEYb3s7SW+iylR7A/BRANubS9oYuEzSRsAhwLdtnyFpeWAc8Dlgs25cRh0REe1ryhHOTsBPbT9uezFwUcu288vvrXloOwE/ALB9O3APsBFwHfAvkj4LvMT248O9sKSpkmZJmvXUY4s78mYiIuL5mtJw2slEa81DG3C87R8BbwMeB34h6XXDvXCy1CIi6tGUhjMTeGv5bGYi8OZhxl8N7AdQTqWtD9whaUPgbtvHUSVGbwEsBtJJIiJ6rBENx/aNVA1iHtUptFnAw0NM+W9gnKSbqTLaDrT9BPAu4BZJc4GNgdNt/xm4pjygLRcNRET0SGOy1CRNtP2IpAlURzBTSzhnbVZeewNvvP/Rdb5kjFBu/IxonrGYpTZN0iZUz8A5re5mA/DK9V7IrPyDFhHRFY1pOLbf2+saIiKiexrTcJogWWqdk1NfEdFfIy4aWBKSru11DRER0b4x23Bsv6bXNURERPvGbMOR9EjL8mdKrto8SceUdS+VdKmk2ZJmlAiciIjokTH/GY6kPYG9gVfbfkzSGmXTNOAQ23dJejXVvTvDJg9ERER3jPmGQxXmeYrtxwBsP1TSCl4DnCP9XwrOCgNNljQVmAqw/Cov7H61ERHLqKWh4Qjof/fqC4C/tJMQbXsa1dEQK6+9QTPugo2IWAqN2c9wWlwGHFwSCpC0hu2/AgskvaOsk6RX9bLIiIhl3ZhvOLYvpcphm1Uy1Poe3LYf8AFJ84Bbgb16VGJERDCGT6nZntiyfAzVkz1bty8A9qi7roiIGNiYbTjdkCy1iIjuaUxadBNIWgzc0es6BrEm8GCvixhCk+tLbUumybVBs+tb1mp7ie21hhuUI5znuqOdiO1ekDSrqbVBs+tLbUumybVBs+tLbQMb8xcNRETE2JCGExERtUjDea5pvS5gCE2uDZpdX2pbMk2uDZpdX2obQC4aiIiIWuQIJyIiarHMNBxJe0i6Q9JvJX1ugO0rSDq7bP+1pMkt2z5f1t8h6R+bUpukN5bHL9xcfu94GvZovm9l+/qSHpH0qf5ze1mbpC0kXSfp1vL9W7Ep9UlaTtJppa7bJH2+B7W9VtIcSU9J2rfftgMk3VV+HdCU2iRt2fJnOl/Suzpd22jqa9m+qqT7JB3fpNrKz+pl5e/cb/r/LHeE7aX+FzAO+B2wIbA8MA/YpN+YQ4ETyvK7gbPL8iZl/ArABmU/4xpS21bAumV5M+C+pnzfWrafB5wDfKoptVHdDjAfeFX5+oWd/DPtQH3vBc4qyxOAhcDkmmubDGwBnA7s27J+DeDu8vvqZXn1htS2EfDysrwu8AAwqQd/rgPW17L928CPgOObVBswHXhjWZ4ITOhkfbaXmSOc7YDf2r7b9t+Bs3h+ttpewGll+Vzg9ZJU1p9l+wlXcTm/LfvreW22b7J9f1l/K7CipAEfw1B3bQCS9qb6B+nWDtbUidp2B+bbngdg+8+2n25QfQZWljQeWAn4O/DXOmuzvdD2fOCZfnP/Ebjc9kO2FwGX09kIqSWuzfadtu8qy/cDfwSGvRmxrvoAJG0DvIgqdLjTlrj5fcpxAAAFHUlEQVQ2SZsA421fXsY94vLIl05aVhrOi4E/tHx9b1k34BjbTwEPU/3Pt525vaqt1T7ATbafaEJtklYGPgsc3cF6OlIb1f+ELekX5fTCZxpW37nAo1T/Q/898HXbD9VcWzfm1rZ/SdtR/S//dx2qq88S1yfpBcA3gE93uKY+o/nebQT8RdL5km6S9DVJ4zpd4LKSNKAB1vW/PG+wMe3MHY3R1FZtlDYFjqX6n3snjaa2o4Fv2X5EGmjIqI2mtvHATsC2wGPAFZJm276iIfVtBzxNdVpodWCGpF/avrvG2roxt5b9S1oH+AFwgO3nHWWM0mjqOxT4ue0/9PBnYjDjgZ2pTtP/HjgbOBD4n45UViwrRzj3Av+v5ev1gPsHG1NOZawGPNTm3F7VhqT1gAuA99vu9P/mRlPbq4GvSloIHAH8i6TDGlLbvcBVth8spw1+DmzdwdpGW997gUttP2n7j8A1QCejSEbzd7oJPw+DkrQq8DPgSNvXd7CuPqOpbwfgsPIz8XXg/ZKOGXpKbbXdS3WG5O5ytP0TOv8zscxcNDCe6rOEDXj2w7RN+435KM/9APfHZXlTnnvRwN109qKB0dQ2qYzfp2nft35jjqLzFw2M5vu2OjCH6gP58cAvgTc3qL7PAqdQ/Y91ZeA3wBZ11tYy9lSef9HAgvI9XL0sr9GQ2pYHrgCO6MbPw2jr67ftQDp/0cBovnfjyvi1ytenAB/t+PevW38wTfsFvAm4k+qc7hfKuq8AbyvLK1JdTfVb4AZgw5a5Xyjz7gD2bEptwJFU5/rntvz6hybU1m8fR9HhhtOBP9P3UV3McAvw1Sb9naO6QuicUt9vgE/3oLZtqf7X+yjwZ+DWlrkHl5p/CxzUlNrKn+mT/X4etmxKff32cSAdbjgd+HN9I9XVmzdTNaTlO11fkgYiIqIWy8pnOBER0WNpOBERUYs0nIiIqEUaTkRE1CINJyIiapGGEzHGlZTkN7V8/baBkoIjei2XRUfUQNI4dz4gtC+h4H3AFNudTHKI6Lg0nIhRKs8NuRT4NVUW1Z3A+6lu2jyZKuPueOB24ASqhIPfAQfbXiRpOtVNitsBq5b1N0hao8zfkCrzbart+ZKOospZmww8SJULtxJwH/CfZXmK7cMkvaTsYy3gT1Q3av5e0qlUCdRTgLWBz9g+tyvfoIgip9QiOuMVwDTbW1D9Q35oWf832zvZPovqGSSfLWNuBr7cMn9l268p804u646myrfaAviXMr/PNsBett8LfInqWTpb2j67X13HA6eXfZwBHNeybR2qZvUWoJOZXhEDSsOJ6Iw/2L6mLP+Q6h9yqFJ3kbQa1cPArirrTwNe2zL/TADbVwOrSppU9vGDsv5XVI99WK2Mv9D2423UtQPVw74o+9qpZdtPbD9j+zdUz2iJ6Ko0nIjO6H9uuu/rR0cxf6i4+Xb3O9TrtD47qSt5+RGt0nAiOmN9STuU5fcAM1s32n4YWCRp57Jqf+CqliHvApC0E/BwGX81sF9ZvyvwoO2Bnvy5GFhlkLqupUqipuxr5iDjIrouDSeiM24DDpA0nyrC/3sDjDkA+FoZsyVVim+fRZKupbqo4ANl3VHAlDL+mDJ/IFcCm0iaK+ld/bYdDhxU9rE/8PERv7OIDslVahGjVK5Su9j2Zks4fzrV4xtmdbCsiMbJEU5ERNQiRzgREVGLHOFEREQt0nAiIqIWaTgREVGLNJyIiKhFGk5ERNQiDSciImrx/wFSxX7J1QzgPQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "bar_chart_solution_2()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you're interested in seeing the code used to generate the solution plots, you can find it in the `solutions_univ.py` script in the workspace folder. You can navigate there by clicking on the Jupyter icon in the upper left corner of the workspace. Spoiler warning: the script contains solutions for all of the workspace exercises in this lesson, so take care not to spoil your practice!" - ] - } - ], - "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.6.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} +{"cells":[{"cell_type":"markdown","metadata":{},"source":["In workspaces like this one, you will be able to practice visualization techniques you've seen in the course materials. In this particular workspace, you'll practice creating single-variable plots for categorical data."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# prerequisite package imports\n","import numpy as np\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","import seaborn as sb\n","\n","%matplotlib inline\n","\n","# solution script imports\n","from solutions_univ import bar_chart_solution_1, bar_chart_solution_2"]},{"cell_type":"markdown","metadata":{},"source":["In this workspace, you'll be working with this dataset comprised of attributes of creatures in the video game series Pokémon. The data was assembled from the database of information found in [this GitHub repository](https://github.com/veekun/pokedex/tree/master/pokedex/data/csv)."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["df = pd.read_csv('./data/pokemon.csv')\n","df.head()"]},{"cell_type":"markdown","metadata":{},"source":["**Task 1**: There have been quite a few Pokémon introduced over the series' history. How many were introduced in each generation? Create a _bar chart_ of these frequencies using the 'generation_id' column."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# YOUR CODE HERE\n","sb.countplot(data=df, x=df['generation_id'], color=sb.color_palette()[2])"]},{"cell_type":"markdown","metadata":{},"source":["Once you've created your chart, run the cell below to check the output from our solution. Your visualization does not need to be exactly the same as ours, but it should be able to come up with the same conclusions."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["bar_chart_solution_1()"]},{"cell_type":"markdown","metadata":{},"source":["**Task 2**: Each Pokémon species has one or two 'types' that play a part in its offensive and defensive capabilities. How frequent is each type? The code below creates a new dataframe that puts all of the type counts in a single column."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["pkmn_types = df.melt(id_vars = ['id','species'], \n"," value_vars = ['type_1', 'type_2'], \n"," var_name = 'type_level', value_name = 'type').dropna()\n","pkmn_types.head()"]},{"cell_type":"markdown","metadata":{},"source":["Your task is to use this dataframe to create a _relative frequency_ plot of the proportion of Pokémon with each type, _sorted_ from most frequent to least. **Hint**: The sum across bars should be greater than 100%, since many Pokémon have two types. Keep this in mind when considering a denominator to compute relative frequencies."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# YOUR CODE HERE\n","# base_color = sb.color_palette()[2]\n","# sb.countplot(data=pkmn_types, x='type', color=base_color)\n","\n","# n_points = pkmn_types.shape[0]\n","# max_count = pkmn_types['type'].value_counts().max()\n","# max_props = max_count / n_points\n","\n","# # generate tick mark location and names\n","# tick_props = np.arange(0, max_props, 0.02)\n","# tick_names = ['{:0.2f}'.format(v) for v in tick_props]\n","\n","\n","# plt.yticks(tick_props*n_points, tick_names)\n","# plt.ylabel('proportion')\n","# plt.xticks(rotation=90)\n","\n","# get order of bars by frequency\n","type_counts = pkmn_types['type'].value_counts()\n","type_order = type_counts.index\n","\n","# compute largest proportion\n","n_pokemon = pkmn_types['species'].unique().shape[0]\n","max_type_count = type_counts[0]\n","max_prop = max_type_count / n_pokemon\n","\n","# establish tick locations and create plot\n","base_color = sb.color_palette()[2]\n","tick_props = np.arange(0, max_prop, 0.02)\n","tick_names = ['{:0.2f}'.format(v) for v in tick_props]\n","\n","base_color = sb.color_palette()[0]\n","sb.countplot(data = pkmn_types, y = 'type', color = base_color, order = type_order)\n","plt.xticks(tick_props * n_pokemon, tick_names)\n","plt.xlabel('proportion')\n","\n","\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["bar_chart_solution_2()"]},{"cell_type":"markdown","metadata":{},"source":["If you're interested in seeing the code used to generate the solution plots, you can find it in the `solutions_univ.py` script in the workspace folder. You can navigate there by clicking on the Jupyter icon in the upper left corner of the workspace. Spoiler warning: the script contains solutions for all of the workspace exercises in this lesson, so take care not to spoil your practice!"]}],"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.6.3"}},"nbformat":4,"nbformat_minor":2} \ No newline at end of file diff --git a/Matplotlib/Histogram_Practice.ipynb b/Matplotlib/Histogram_Practice.ipynb index 9348dab..05347d6 100644 --- a/Matplotlib/Histogram_Practice.ipynb +++ b/Matplotlib/Histogram_Practice.ipynb @@ -1,292 +1 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# prerequisite package imports\n", - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sb\n", - "\n", - "%matplotlib inline\n", - "\n", - "from solutions_univ import histogram_solution_1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We'll continue working with the Pokémon dataset in this workspace." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idspeciesgeneration_idheightweightbase_experiencetype_1type_2hpattackdefensespeedspecial-attackspecial-defense
01bulbasaur10.76.964grasspoison454949456565
12ivysaur11.013.0142grasspoison606263608080
23venusaur12.0100.0236grasspoison80828380100100
34charmander10.68.562fireNaN395243656050
45charmeleon11.119.0142fireNaN586458808065
\n", - "
" - ], - "text/plain": [ - " id species generation_id height weight base_experience type_1 \\\n", - "0 1 bulbasaur 1 0.7 6.9 64 grass \n", - "1 2 ivysaur 1 1.0 13.0 142 grass \n", - "2 3 venusaur 1 2.0 100.0 236 grass \n", - "3 4 charmander 1 0.6 8.5 62 fire \n", - "4 5 charmeleon 1 1.1 19.0 142 fire \n", - "\n", - " type_2 hp attack defense speed special-attack special-defense \n", - "0 poison 45 49 49 45 65 65 \n", - "1 poison 60 62 63 60 80 80 \n", - "2 poison 80 82 83 80 100 100 \n", - "3 NaN 39 52 43 65 60 50 \n", - "4 NaN 58 64 58 80 80 65 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pokemon = pd.read_csv('./data/pokemon.csv')\n", - "pokemon.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Task**: Pokémon have a number of different statistics that describe their combat capabilities. Here, create a _histogram_ that depicts the distribution of 'special-defense' values taken. **Hint**: Try playing around with different bin width sizes to see what best depicts the data." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# YOUR CODE HERE\n", - "plt.figure(figsize=[20,10])\n", - "plt.subplot(1,3,1)\n", - "bin_edges = np.arange(0, pokemon['special-defense'].max()+1, 1);\n", - "plt.hist(data=pokemon, x='special-defense', bins=bin_edges);\n", - "\n", - "plt.subplot(1,3,2)\n", - "bin_edges = np.arange(0, pokemon['special-defense'].max()+5, 5);\n", - "plt.hist(data=pokemon, x='special-defense', bins=bin_edges);\n", - "\n", - "plt.subplot(1,3,3)\n", - "# bin_edges = np.arange(0, pokemon['special-defense'].max()+8, 8);\n", - "# plt.hist(data=pokemon, x='special-defense', bins=bin_edges);\n", - "sb.distplot(pokemon['special-defense'])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "I've used matplotlib's hist function to plot the data. I have also used numpy's arange function to set the bin edges. A bin size of 5 hits the main cut points, revealing a smooth, but skewed curves. Are there similar characteristics among Pokemon with the highest special defenses?\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# run this cell to check your work against ours\n", - "histogram_solution_1()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.6.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} +{"cells":[{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# prerequisite package imports\n","import numpy as np\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","import seaborn as sb\n","\n","%matplotlib inline\n","\n","from solutions_univ import histogram_solution_1"]},{"cell_type":"markdown","metadata":{},"source":["We'll continue working with the Pokémon dataset in this workspace."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["pokemon = pd.read_csv('./data/pokemon.csv')\n","pokemon.head()"]},{"cell_type":"markdown","metadata":{},"source":["**Task**: Pokémon have a number of different statistics that describe their combat capabilities. Here, create a _histogram_ that depicts the distribution of 'special-defense' values taken. **Hint**: Try playing around with different bin width sizes to see what best depicts the data."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# YOUR CODE HERE\n","plt.figure(figsize=[20,10])\n","plt.subplot(1,3,1)\n","bin_edges = np.arange(0, pokemon['special-defense'].max()+1, 1);\n","plt.hist(data=pokemon, x='special-defense', bins=bin_edges);\n","\n","plt.subplot(1,3,2)\n","bin_edges = np.arange(0, pokemon['special-defense'].max()+5, 5);\n","plt.hist(data=pokemon, x='special-defense', bins=bin_edges);\n","\n","plt.subplot(1,3,3)\n","# bin_edges = np.arange(0, pokemon['special-defense'].max()+8, 8);\n","# plt.hist(data=pokemon, x='special-defense', bins=bin_edges);\n","sb.distplot(pokemon['special-defense'])\n"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# run this cell to check your work against ours\n","histogram_solution_1()"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]}],"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.6.3"}},"nbformat":4,"nbformat_minor":2} \ No newline at end of file diff --git a/Matplotlib/bar_chart.ipynb b/Matplotlib/bar_chart.ipynb index b8db876..7c9458c 100644 --- a/Matplotlib/bar_chart.ipynb +++ b/Matplotlib/bar_chart.ipynb @@ -1,572 +1 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sb\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(807, 14)\n" - ] - }, - { - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idspeciesgeneration_idheightweightbase_experiencetype_1type_2hpattackdefensespeedspecial-attackspecial-defense
01bulbasaur10.76.964grasspoison454949456565
12ivysaur11.013.0142grasspoison606263608080
23venusaur12.0100.0236grasspoison80828380100100
34charmander10.68.562fireNaN395243656050
45charmeleon11.119.0142fireNaN586458808065
\n", - "
" - ], - "text/plain": [ - " id species generation_id height weight base_experience type_1 \\\n", - "0 1 bulbasaur 1 0.7 6.9 64 grass \n", - "1 2 ivysaur 1 1.0 13.0 142 grass \n", - "2 3 venusaur 1 2.0 100.0 236 grass \n", - "3 4 charmander 1 0.6 8.5 62 fire \n", - "4 5 charmeleon 1 1.1 19.0 142 fire \n", - "\n", - " type_2 hp attack defense speed special-attack special-defense \n", - "0 poison 45 49 49 45 65 65 \n", - "1 poison 60 62 63 60 80 80 \n", - "2 poison 80 82 83 80 100 100 \n", - "3 NaN 39 52 43 65 60 50 \n", - "4 NaN 58 64 58 80 80 65 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pokeman = pd.read_csv('pokemon.csv')\n", - "print(pokeman.shape)\n", - "pokeman.head(5)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ0AAAEKCAYAAADJvIhZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nmySdiIhomySdiIhom/8PYZbPEu6Mr1wAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sb.countplot(data=pokeman, y='type_1')" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "base_color = sb.color_palette()[1]" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", - " 17]), )" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEnCAYAAACkK0TUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sb.countplot(data=pokeman, x='type_2', color=base_color)\n", - "plt.xticks(rotation=90)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0,0.5,'proportion')" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEnCAYAAABYPm8eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIiIiGiVYREREo/8H624KXI/J19MAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Absolute vs. Relative Frequency\n", - "# By default, seaborn's countplot function will summarize and plot the data in terms of absolute frequency, or pure counts\n", - "#One method of plotting the data in terms of relative frequency on a bar chart is to just relabel the counts axis in terms of proportions. \n", - "n_points = pokeman.shape[0]\n", - "\n", - "max_count = pokeman['type_1'].value_counts().max()\n", - "max_prop = max_count / n_points\n", - "# generate tick mark location and names\n", - "tick_props = np.arange(0, max_prop, 0.05)\n", - "tick_names = ['{:0.2f}'.format(v) for v in tick_props]\n", - "\n", - "# create the plot\n", - "base_color = sb.color_palette()[2]\n", - "sb.countplot(data=pokeman, x='type_1', color=base_color)\n", - "plt.xticks(rotation=90)\n", - "plt.yticks(tick_props*n_points, tick_names)\n", - "plt.ylabel('proportion')" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", - " 17]), )" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEnCAYAAACzCdQdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nPuiRC1PxwHEAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Rather than plotting the data on a relative frequency scale, you might use text annotations to label the frequencies on bars instead\n", - "\n", - "base_color = sb.color_palette()[2]\n", - "sb.countplot(data=pokeman, x='type_1', color=base_color)\n", - "n_points = pokeman.shape[0]\n", - "type_counts = pokeman['type_1'].value_counts()\n", - "locs, labels = plt.xticks()\n", - "for loc, label in zip(locs, labels):\n", - " count = type_counts[label.get_text()]\n", - " pct_string = '{:0.1f}%'.format(100*count/n_points)\n", - " plt.text(loc, count-8, pct_string, ha='center', color='w')\n", - "plt.xticks(rotation=90)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Counting missing Data" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idspeciesgeneration_idheightweightbase_experiencetype_1type_2hpattackdefensespeedspecial-attackspecial-defense
01bulbasaur10.76.964grasspoison454949456565
12ivysaur11.013.0142grasspoison606263608080
23venusaur12.0100.0236grasspoison80828380100100
34charmander10.68.562fireNaN395243656050
45charmeleon11.119.0142fireNaN586458808065
\n", - "
" - ], - "text/plain": [ - " id species generation_id height weight base_experience type_1 \\\n", - "0 1 bulbasaur 1 0.7 6.9 64 grass \n", - "1 2 ivysaur 1 1.0 13.0 142 grass \n", - "2 3 venusaur 1 2.0 100.0 236 grass \n", - "3 4 charmander 1 0.6 8.5 62 fire \n", - "4 5 charmeleon 1 1.1 19.0 142 fire \n", - "\n", - " type_2 hp attack defense speed special-attack special-defense \n", - "0 poison 45 49 49 45 65 65 \n", - "1 poison 60 62 63 60 80 80 \n", - "2 poison 80 82 83 80 100 100 \n", - "3 NaN 39 52 43 65 60 50 \n", - "4 NaN 58 64 58 80 80 65 " - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = pd.read_csv('pokemon.csv')\n", - "df.head(5)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]),\n", - " )" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAFGCAYAAABkGFRGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "na_counts = df.isna().sum()\n", - "base_color = sb.color_palette()[2]\n", - "sb.barplot(na_counts.index.values, na_counts, color=base_color)\n", - "plt.xticks(rotation=90)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [default]", - "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.6.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} +{"cells":[{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["import numpy as np\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","import seaborn as sb\n","\n","%matplotlib inline"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["pokeman = pd.read_csv('pokemon.csv')\n","print(pokeman.shape)\n","pokeman.head(5)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["sb.countplot(data=pokeman, y='type_1')"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["base_color = sb.color_palette()[1]"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["sb.countplot(data=pokeman, x='type_2', color=base_color)\n","plt.xticks(rotation=90)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Absolute vs. Relative Frequency\n","# By default, seaborn's countplot function will summarize and plot the data in terms of absolute frequency, or pure counts\n","#One method of plotting the data in terms of relative frequency on a bar chart is to just relabel the counts axis in terms of proportions. \n","n_points = pokeman.shape[0]\n","\n","max_count = pokeman['type_1'].value_counts().max()\n","max_prop = max_count / n_points\n","# generate tick mark location and names\n","tick_props = np.arange(0, max_prop, 0.05)\n","tick_names = ['{:0.2f}'.format(v) for v in tick_props]\n","\n","# create the plot\n","base_color = sb.color_palette()[2]\n","sb.countplot(data=pokeman, x='type_1', color=base_color)\n","plt.xticks(rotation=90)\n","plt.yticks(tick_props*n_points, tick_names)\n","plt.ylabel('proportion')"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Rather than plotting the data on a relative frequency scale, you might use text annotations to label the frequencies on bars instead\n","\n","base_color = sb.color_palette()[2]\n","sb.countplot(data=pokeman, x='type_1', color=base_color)\n","n_points = pokeman.shape[0]\n","type_counts = pokeman['type_1'].value_counts()\n","locs, labels = plt.xticks()\n","for loc, label in zip(locs, labels):\n"," count = type_counts[label.get_text()]\n"," pct_string = '{:0.1f}%'.format(100*count/n_points)\n"," plt.text(loc, count-8, pct_string, ha='center', color='w')\n","plt.xticks(rotation=90)"]},{"cell_type":"markdown","metadata":{},"source":["## Counting missing Data"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["df = pd.read_csv('pokemon.csv')\n","df.head(5)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["na_counts = df.isna().sum()\n","base_color = sb.color_palette()[2]\n","sb.barplot(na_counts.index.values, na_counts, color=base_color)\n","plt.xticks(rotation=90)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]}],"metadata":{"kernelspec":{"display_name":"Python [default]","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.6.3"}},"nbformat":4,"nbformat_minor":2} \ No newline at end of file diff --git a/Matplotlib/matplotlib.ipynb b/Matplotlib/matplotlib.ipynb index 82013d1..c7f5c40 100644 --- a/Matplotlib/matplotlib.ipynb +++ b/Matplotlib/matplotlib.ipynb @@ -1,829 +1 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sb\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(807, 14)\n" - ] - }, - { - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idspeciesgeneration_idheightweightbase_experiencetype_1type_2hpattackdefensespeedspecial-attackspecial-defense
01bulbasaur10.76.964grasspoison454949456565
12ivysaur11.013.0142grasspoison606263608080
23venusaur12.0100.0236grasspoison80828380100100
34charmander10.68.562fireNaN395243656050
45charmeleon11.119.0142fireNaN586458808065
\n", - "
" - ], - "text/plain": [ - " id species generation_id height weight base_experience type_1 \\\n", - "0 1 bulbasaur 1 0.7 6.9 64 grass \n", - "1 2 ivysaur 1 1.0 13.0 142 grass \n", - "2 3 venusaur 1 2.0 100.0 236 grass \n", - "3 4 charmander 1 0.6 8.5 62 fire \n", - "4 5 charmeleon 1 1.1 19.0 142 fire \n", - "\n", - " type_2 hp attack defense speed special-attack special-defense \n", - "0 poison 45 49 49 45 65 65 \n", - "1 poison 60 62 63 60 80 80 \n", - "2 poison 80 82 83 80 100 100 \n", - "3 NaN 39 52 43 65 60 50 \n", - "4 NaN 58 64 58 80 80 65 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pokeman = pd.read_csv('pokemon.csv')\n", - "print(pokeman.shape)\n", - "pokeman.head(5)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ0AAAEKCAYAAADJvIhZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nmySdiIhomySdiIhom/8PYZbPEu6Mr1wAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sb.countplot(data=pokeman, y='type_1')" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "base_color = sb.color_palette()[1]" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", - " 17]), )" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEnCAYAAACkK0TUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sb.countplot(data=pokeman, x='type_2', color=base_color)\n", - "plt.xticks(rotation=90)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0,0.5,'proportion')" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEnCAYAAABYPm8eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIiIiGiVYREREo/8H624KXI/J19MAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Absolute vs. Relative Frequency\n", - "# By default, seaborn's countplot function will summarize and plot the data in terms of absolute frequency, or pure counts\n", - "#One method of plotting the data in terms of relative frequency on a bar chart is to just relabel the counts axis in terms of proportions. \n", - "n_points = pokeman.shape[0]\n", - "\n", - "max_count = pokeman['type_1'].value_counts().max()\n", - "max_prop = max_count / n_points\n", - "# generate tick mark location and names\n", - "tick_props = np.arange(0, max_prop, 0.05)\n", - "tick_names = ['{:0.2f}'.format(v) for v in tick_props]\n", - "\n", - "# create the plot\n", - "base_color = sb.color_palette()[2]\n", - "sb.countplot(data=pokeman, x='type_1', color=base_color)\n", - "plt.xticks(rotation=90)\n", - "plt.yticks(tick_props*n_points, tick_names)\n", - "plt.ylabel('proportion')" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", - " 17]), )" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEnCAYAAACzCdQdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nPuiRC1PxwHEAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Rather than plotting the data on a relative frequency scale, you might use text annotations to label the frequencies on bars instead\n", - "\n", - "base_color = sb.color_palette()[2]\n", - "sb.countplot(data=pokeman, x='type_1', color=base_color)\n", - "n_points = pokeman.shape[0]\n", - "type_counts = pokeman['type_1'].value_counts()\n", - "locs, labels = plt.xticks()\n", - "for loc, label in zip(locs, labels):\n", - " count = type_counts[label.get_text()]\n", - " pct_string = '{:0.1f}%'.format(100*count/n_points)\n", - " plt.text(loc, count-8, pct_string, ha='center', color='w')\n", - "plt.xticks(rotation=90)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Counting missing Data" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idspeciesgeneration_idheightweightbase_experiencetype_1type_2hpattackdefensespeedspecial-attackspecial-defense
01bulbasaur10.76.964grasspoison454949456565
12ivysaur11.013.0142grasspoison606263608080
23venusaur12.0100.0236grasspoison80828380100100
34charmander10.68.562fireNaN395243656050
45charmeleon11.119.0142fireNaN586458808065
\n", - "
" - ], - "text/plain": [ - " id species generation_id height weight base_experience type_1 \\\n", - "0 1 bulbasaur 1 0.7 6.9 64 grass \n", - "1 2 ivysaur 1 1.0 13.0 142 grass \n", - "2 3 venusaur 1 2.0 100.0 236 grass \n", - "3 4 charmander 1 0.6 8.5 62 fire \n", - "4 5 charmeleon 1 1.1 19.0 142 fire \n", - "\n", - " type_2 hp attack defense speed special-attack special-defense \n", - "0 poison 45 49 49 45 65 65 \n", - "1 poison 60 62 63 60 80 80 \n", - "2 poison 80 82 83 80 100 100 \n", - "3 NaN 39 52 43 65 60 50 \n", - "4 NaN 58 64 58 80 80 65 " - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = pd.read_csv('pokemon.csv')\n", - "df.head(5)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]),\n", - " )" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAFGCAYAAABkGFRGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "na_counts = df.isna().sum()\n", - "base_color = sb.color_palette()[2]\n", - "sb.barplot(na_counts.index.values, na_counts, color=base_color)\n", - "plt.xticks(rotation=90)" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-1.1024628863899109,\n", - " 1.1087124072032752,\n", - " -1.1013649972570692,\n", - " 1.1098102963361169)" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAASgAAADwCAYAAACzHfnvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nipY4QMXExBQtcYCKiYkpWv4Pq1b3mpEKn+YAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# pie charts\n", - "sorted_counts = df['type_1'].value_counts()\n", - "plt.pie(sorted_counts, labels = sorted_counts.index, startangle = 0,\n", - " counterclock = True);\n", - "plt.axis('square') # this will make the results a circle" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-1.1024628863899109,\n", - " 1.1087124072032752,\n", - " -1.1013649972570692,\n", - " 1.1098102963361169)" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAASgAAADwCAYAAACzHfnvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJztnXl4VOX5v+9nJpOENWHfIkRQTMQg\nKigqu1st1N1iF4tLa6m0Vmtb08U6tlVjW+yvWltcqsSv2lK3VqXaWpFdBGSLkqAiAcK+hj3LzPP7\n4z2pQ8wyy5k5M5NzX9dcmZzznvc8k8x85l2eRVQVFxcXl2TE47QBLi4uLs3hCpSLi0vS4gqUi4tL\n0uIKlIuLS9LiCpSLi0vS4gqUi4tL0uIKlIuLS9LiCpSLi0vS4gqUi4tL0uIKlIuLS9LiCpSLS5wQ\nkbkiMtxpO1IZV6BcXJpARDKctsEF3H+CS9oiIvnAG8BC4DxgC3A5cAowA2gPrAduUtV9IjIXWAyc\nD7wqIkXAUaAAGADcCEwBzgXeU9UbrPv8GRgBtANeVNV7EvIC2wDuCMol3TkZeFRVhwD7gauBZ4C7\nVHUoUAaECkquqo5V1enW712ACcAdwGvA74EhQJGIDLPa/ExVhwNDgbEiMjTeL6qt4AqUS7qzQVVX\nWc/fBwZhRGiedawUGBPSflaj619Tk5OoDNihqmWqGgQ+BPKtNl8WkRXASox4nWr/y2ibuFM8l3Sn\nJuR5AMhtpf3hZq4PNuorCGSIyInAD4ER1jRxJpAdvbkuobgjKJe2RjWwT0RGW79fD8xroX1rdMaI\nWrWI9AIujdE+lxDcEVQCEJEMVa132g6X/zEFmCEi7YFPMYvfUaGqq0VkJWbK9ymwyB4TXQDETfkb\nOyJyN/A1YDOwG7PWMYmQHSHgI+DnQCawB/iaqu4QkbHAH6yuFLMe0hGzFtIZ8yXyHVVdkLAX5OKS\nJLgjqBixHPGuBs7A/D1XYAQKrB0hq10XYKSqqoh8E/gxcCdm/WKaqi4SkY7AMeAW4N+qep+IeDHb\n4S4ubQ5XoGJnFPBPVT0KICKvhZwL3RHKA2aJSB/MKGqDdXwR8JCIPAe8rKpVIrIMeEpEfMA/Qnah\nkgd/TieMb1Ae0AmzMNzwaNfE80zgELC3hcc+/NXBhL4Ol6TGFajYkRbOhe4IPQI8pKqvisg4wA+g\nqiUiMhv4IrBERC5U1fkiMgaYCPyfiPxWVZ+Jj/nNU1Ra1A0owjg2Dj7j2LGsZ7btHAP0B3LicEvF\nn7MPMx3+ALO1bx7+6t1xuJ9LkuMKVOwsBB4TkQcwf8+JwBNNtMvBeDKDWaQFQEQGqWoZUCYi5wIF\nInIU2KKqT4hIB+BMjHNh3CgqLcrGTFPPAc62fg4MbfNxZuYHwGlxNEOArsBI6/EZ/pwdfCZaHwCr\ngZX4qwNxtMfFYVyBihFVXSYir2I+MBuB5Zit7Mb4gRdEZAuwBDjROn67iIzH+OisxYRmXAf8SETq\nMNOib9htd1FpURYwHrMtfj7GC9rX0jWHRXrbbUcE9LIeF4Qcq8afMw/4L/A2/uq1jljmEjfcXTwb\nEJGOqnrI2raeD9yiqiuctqsxRaVF/TAjvImYD3qHSPtYUrn5UAfVjnbbZhNbgNmYkJS38Vcfddge\nlxhxBcoGROR5THhDNlCqqg84bNL/KCotOgnjjHgZMKyV5q3y3Nbt64bW1J4Ss2Hx5yjwNvAi8AL+\n6iMO2+MSBa5ApSFFpUUdgWsxDoijW2keET/fvfe9yQcPnWNnnwmgGngOeAJ/dfLtiLo0iytQaURR\nadEYjChdSxTTt3C4+sChef49e8fGo+8EsRx4HPgr/upDThvj0jKuQKU4RaVF7TCidDsmtUhcGXqs\nZsFz23bYOipziEPA3zCjqqVOG+PSNK5ApShFpUXdge8BtwLdE3Xf7vWB99/ZvOWsRN0vQawA7sVf\n/arThrgcjytQKUZRaVEf4EeYcJi4TONaIkN148rKzQMSfd8EsRT4Of7qt5w2xMXgClSKUFRa1BX4\nBTAVyHLMENX6VZWbxQtex2yIP/OAn+GvdjMTOIwrUElOUWmRD/gucDcm/azjvL556+YB9fUnOG1H\nAngDM6JKOp+2toKbsC6JKSotuhyTZ+ghkkScANZl+nY5bUOCuBRYjj/nJfw5hU4b0xZxR1BJSFFp\n0TCMKI132pamuHl/9YLb91Wnw05eJNQB9wP34a+uc9qYtoI7gkoiikqLsotKi36DySeVlOIEsC4z\nsy0G6Pow1V/ex5+TbruYSYsrUElCUWnROZiqID8iyf8vG30ZbbkoQBHwHv6cEvw5bfnvkBDcKZ7D\nWFkFfonJrpkSO2PtgsGKpRurCpy2IwmoAG7CX/2u04akK65AOUhRadHZwEwgtRZgVQ+UVW7u7LQZ\nSUIQk4zwp25Asv0k9VQinSkqLSrGFFVILXECEOm81+PZ67QZSYIH+D6wxl2bsh9XoBJMUWlRp6LS\nopeBB0iRKV1TfJLp2+a0DUnGIGAh/pybnDYknXAFKoEUlRYVAsuAK522JVbKMzObyhra1skG/oI/\n5zH8OZlOG5MOuAKVIIpKi67BxHqlQrK3VinPyqx12oYk5pbt2uX5/OLZfZw2JNVxBSrOFJUWeSzf\nphcwBTnTgvU+n5vPvhkCKruuqfWfCyzNL54dcxbTtowrUHHEqpTyAsa3Ka3YluHt5LQNyYgqtTfW\n/Xhblfboi6kZuDC/ePZlTtuVqrgCFSeKSou6AG8BVzltSzw46PH0dNqGZOTRwOXvzQ+ePjTkUAfg\nlfzi2T90yqZUxhWoOFBeUNj37ucDMzBVh9OSIPSuhRqn7UgmlgcHz/9d/eSmYhQ9wG/zi2cnTTGN\nVMEVKJspLygcCCwo2qhfvuuFwDyn7YkbIrLB59vSesO2wT7tuGpy7d3ntdKsOL949i8TYlCa4AqU\njZQXFJ4CLMCqyHvWJzr25jfTV6QqsjL3OG1DMlCn3qoLan57QgBvOBsHd+cXz/5F3I1KE1yBsony\ngsITMXXY+oYev3iljrlicTAtMzOuzcxs84UxVTl8be09h/eS0y2Cy+7NL579k7gZlUa4AmUD5QWF\nfTHlt/s1PicgX5kXPGdsWXBZ4i2LLx9n+tp8IOc99VPWrNKTovFtu99dOG8dV6BipLygsAdGnAY2\n10Yg49bXg6edvj64JnGWxZ/Nvoz2TtvgJP8ODJ/7TOCSc2Po4rf5xbNvt82gNMQVqBgoLyjMAf5N\nGAG/Au1++vdg/4Hb9OP4W5YY9nq8XZ22wSm2aLel3667w44Cpr/PL579XRv6SUtcgYqS8oLCdsC/\ngDPCvUYg977SQKdee7UqfpYljlqhn0Kbm+YdU9/6i2t+UwgiNnX5cH7x7G/b1Fda4QpU9PwFaG1b\n+XN4ld4PPRGozzmkqV94QCR7u9e7w2kzEklQ2T+x9v6Mw7Sz05NegEfzi2dPsLHPtMAVqCgoLyj8\nCfCVaK/3Bcl/ZEZgd7saPWijWY7wcaavzQiUKoHv1d22fr32i0fhUi/wt/zi2W2hnFfYuAIVIeUF\nhZcB98XaT3YdhY/8OfBJRr2mtDf22qzMQ07bkCieDVy4cHZwZDyT0vUAXswvnu1cYdYkI2UESkTy\nReQDJ20oLyg8DXgOMySPmc5HOeP3TwRWimrQjv6coCIzs02UYCoP9l94d/1NdiyKt8bZwMMJuE9K\nkDIC5TTlBYXdgFexOWVKr/2MvK80kLKOnBt8Pp/TNsSbg9ruw8trfzUigbe8Jb94tpuZk9QTqAwR\nKRWRNSLyooi0F5FKEekOICLDRWSu9byHiLwlIitE5DER2djQLkpmAifG/hI+z0nbGP2jF1MzJGZn\nhjc35NcjwBZgPaYi8vvAIoyH/UJgLbCdFAoyDqjsuLjmN91q8SV62vVofvHsNp/jPNWSjp0C3Kyq\ni0TkKeDWFtreA8xR1QdE5AvALdHetLyg8FZgUrTXh8OIj3Xsjf8JzHv6Ym8iphGxcBRYB5QDa72q\nZcAmYBP+6vBj8/w57YGuGNEvsh6nWT9zbLY5KlSpub7uJ7u30W2IA7fPBl7KL559VmXJxDYb85gy\nZadEJB+Yr6r9rd8nALcBw4DhqrpbRIYDv1PVcSKyCrhSVTdY7fcCg1V1dyT3LS8oPBVYDrSz7cU0\ng4I+N96z+NWRnvPjfa8I+QiYDbwOLCibUhbfdSd/zgnA+cAFwIVAflzv1wwP1V2z8OHAVU6nzPkv\n8IXKkoltsZpzyo2gGqupAvV8NlUNrfQa80J2eUFhFvA8CRAnMHF7X3snePa+jixfcJpneCLu2Qy1\nwHwsUSqbUvZJQu/ur94M/M16gD+nEDOCvQwjXHY5SDbL4sCp8x4OXJUMo9kLgZ9hiru2OVJtBLUB\nOE9V3xWRJzCVXS8FpqvqGyLye+AMawT1KLBJVR8UkYsxISk9IhlBlRcUPgTcYfdraQ2FI7++zrO+\n7ERPUQJvGwBeAf4KvFU2pSw5fbT8OScB3wRuAHrF4xa7tfOKs2v+dHoQT7KUBasBhlaWTPzIaUMS\nTaoJ1L8w3+znAR8D1wNnYby6dwDvYaZ740SkJ+bD1gWYB0wGTlQNz++ovKBwAmZ4Hfdv66ZQ2F98\no3f3ht5yUpxvtR94EnikbErZpjjfyz78OT7MiOoW4CJs+j/VqXfjiJo/dd5Ppy529GcjcypLJl7g\ntBGJJmUEKlJEJAsIqGq9iJwL/FlVw6qwYcXZlWGKMTpGQNh2+7e9gR1dJC8O3W8DHgSeLJtSdjgO\n/ScOf04BZgp0DTEIlSoHJ9bev3Ot5jv6f2+B6ytLJj7rtBGJJJ0F6mTg75j1qVrgVlUNKydTeUHh\n/UBSJBSr87Lh1mneTtUdYnKRCKVBmB4rm1J2zKY+kwN/zjDg18DESC9VRX9S/82lfwtMOMd+w2xj\nJ1BQWTJxn9OGJIq0FahosXbtVgFJ44B41Ef51O95845mSSwBqrWYUcb0tBOmxvhzzsWUlg97kfvV\nwLlzb6v73ri42WQfT1SWTIzaZSYaROR24HFVPZLI+4IrUJ+jvKBwDjDeaTsaU92eFd+Z5h1SnyHR\nOAwuB24om1L2od12JTX+nJuA6UBuS80qg73eHVf70Egb06fEEwVGVZZMXJyoG4pIJZYrTwTXeFU1\nZteIVPMkjyvlBYWTSUJxAsg5wpkPPRFYEWHcXi3wc+DcNidOAP7qp4AhwGvNNTmqmR99sfaBoSki\nTmDW2GbkF8+O2EVIRH4sIrdZz38vInOs5xeIyLMi8mcRWS4iH4rIvda52zB59t8RkXesYxeLyLtW\nlMYLItLROl4pIr8QkYXAtXa8WFegLMoLCrOB3zltR0v03s+5v34msDDM5iuA4WVTyu4rm1JWH0+7\nkhp/9Vb81ZcBXwOOGwEEVfZ8obak/RGyOzhjXNQUAT+I4rr5QEPdvuFARxHxYeo3LgB+pqrDgaHA\nWBEZqqoPA1uB8ao63goX+zlwoaqeiRmdh9pyTFVHqerfonpljXAF6jNuxZSqTmpO3sqYO19qMW6v\nDvgFcE7ZlLKyBJmV/Pirn8eE0swHUKX+23V3bN6ovZP+f94M90SRO+p94CwR6YTxrXoXI1SjMQL1\nZRFZAazEjDxPbaKPkdbxRVa0xhQgND/WrAhtahFXoIDygsKOQLHTdoTLOR/p2BvealKkNmOE6Vdt\netTUHP7qHZjwmf/3l8Cli94KDg/L7SRJaY/xMA8bVa0DKoEbgcUYURqPcac5CvwQuEBVh2KiCLKb\n6EaAt1R1mPU4VVVvDjlvq8uKK1CG2zHJwlKGS5frmEnvBUMXSlcBI8umlK10yqaUwF9dj7/6jl/X\nXz8Ts0aXytyYXzy7f4TXzMcI0XyMQE3FvHc6Y8SlWkR6YSI0GjgINOwgLwHOFzEOxFZGkcHRv4SW\nafMCVV5QmAvc6bQdkSIg188Jjjj/w+By4A1gdNmUsq1O25UqVJZMnInxQE/lTAGZRO6vtwDoA7yr\nqjuAY8ACVV2Nmdp9CDyFSZPTwOPAGyLyjqruwoQZ/VVE1mAEqyCmV9ECbd7NoLyg8D7gp07bES31\nHp786l0Z33GndNGRXzy7AJhLnOL6EkAtcFJlycTNThsSD9r0CMrKkvl9p+2IgccygtziilP0VJZM\nrMCsS6VqlZ1MUmj9NFLatEBhAk1TbYu5gT8UVpRPLawob9tDYBuoLJn4ISatSapO927ML55tVyhU\nUtFmBaq8oDCDljNyJjN/Kawod0tm20hlycQ1GJFKxTi3dsA0p42IB21WoICrSQG/pyZYSOoKa1JT\nWTJxFWbhvNppW6JgWn7x7KbcAlKatixQqbj2tBG4qrCiPNW3x5OWypKJ72PyjKXa1LkHxmkyrWiT\nAlVeUDgCONdpOyLkMHB5YUV5qi7mpgyVJRNfA+532o4oSLtpf5sUKEyxhVRCgesLK8pXO21IG+IX\nmDTRqURBupWqanMCVV5Q2AmTeTGVuKewovwVp41oS1SWTAwCX8WEhqQS1zltgJ20OYECrqLpGKNk\n5Z+FFeW/ctqItkhlycS9mPdLKiX4m5xfPDtVUse0SlsUqK86bUAE7MPESrk4RGXJxJWkVsmnhpqC\naUGbEqjygsJeGK/hVOGHhRXl2502woXfYWLUUoW0mea1KYHClJ5KllpnrTGnsKL8KaeNcIHKkol1\nmJFsqrgeXJtfPDtV3uct0tYEKlWmd3W4zphJRWXJxIWYKP9UoCcwwWkj7KDNCFR5QWF/IJlLCoXy\nx8KK8nVOG+HyOX5M6gQVp8U0r80IFFHUSnOIncC9Thvh8nmsXb2kqJcYBlflF8/OdNqIWGlLAnVp\n602SAn9hRXkqxoK1FUqB9U4bEQa5wCVOGxErbUKgHp06J3Nvl4I+ikRSsskJdgNPO22ES/NUlkys\nB+5z2o4wudBpA2Il4tpaKcq5q07/3nBU97c7uqu81873A322Lx7Y7tjevk4b1ojHCyvKU8kpsK3y\nf8DdwIlOG9IK5zltQKy0iZS/j06dcy8mtuo4JFj3ac6BDVV9tr3brueuVUO8wdr2DpjXQD2QX1hR\nvsVBG1zCJL949m3AH5y2oxXqgZzKkokJL1luF21lBNXklqt6fAP35w4euD93MOUF36jx1R1a2X3P\nBwf6blvUu/OBDYPFlNhJFC+64pRSPAX4gS4O29ESGcAIoKU6iklN2o+gHp06pz2wH/BFdKEGd3U4\nsv2jXjuW0Wf7ksFZtQfiXZbq3MKK8iVxvoeLjeQXz/4dyV8R6KeVJRMfcNqIaGkLI6jziFScAMTT\n43CHvj0+HXg5n554mXqCtR/l7v9ka99ti3O67/ngVI/WZ9lo41JXnFKS50h+gUq1vGfH0RYE6vSY\nexCRoDdr8N5uQwbv7TYEVI9k1lYv77Fr1eG+2xaf0OnwloEx3iHZ1zJcmqCyZOLK/OLZ64BTnLal\nBVyBSnKaqi8fGyLta7Nyh2/JG8eWvHGgga2dDm1Z33v7exm9dywr8NUfjmRd4iDwou02uiSKWTSx\nAZNEdM8vnj24smTiR04bEg1tQaCGxP0O4u17sFP/vgc79efjk64JegPHPuy6b92uvtsWdeuyr6LQ\no8GW/s7/cXOMpzR/JbkFCswyhytQSYr9I6iWEPEEMtoN2dVjGLt6DAPVA9nH9pb33LWitu+2xQPa\nH93Zv9EVryXUPhdbqSyZWJFfPHs1diwlxI/zgJlOGxENaS1Qj06dcwLQyVEjRDofa9ftnE39L2JT\n/4uQYP2mzgc3VvbZviS7584VgzMCx/7lqH0udjCL5BaoEU4bEC1pLVAkYnoXIerJ6F+dM6h/dc4g\nKgZ/dcm0xy5Ileh4l+aZ77QBrTDAaQOiJd1j8ZJOoI5DJGUd6FyOYzmQzOuIXfKLZzsZJRE16S5Q\niV1/ipw5ThvgEjuVJRNrgJVO29EKJzhtQDSku0Al9wgK3nPaABfbWOy0Aa2Q57QB0eCYQInIOBF5\nvZlzT4qIHaOfAhv6iBdbps2Y4OZ9Sh+SXaBScgSVlIvkqvrNWPt4dOqcbCDHBnPixVqnDXCxlWQX\nqPQcQYlIvohUiEipiKwRkRdFpL2IlIjIWuvY70Skk4hsEBGfdV1nEakUEZ+InCQi/xWR1SKyQkQG\nWd13tPqrEJHnRESsa+eKyHDr+Resa1aLyNsRvLZ4B/fGSiqVMXJphcqSiVuBA07b0QJpPYI6BbhZ\nVReJyFPAd4ErgQJVVRHJVdWDIjIXk/v7H5ik7S+pap2IPAeUqOorIpKNEcYTgDMw60RbgUWYgoML\nG24qIj2AJ4AxqrpBRLpG8Nq6R9DWCVyBSj82k7zrnuk5grLYrKqLrOfPAmMw5aCfFJGrgIaEWE8C\nN1rPbwSeFpFOQD9VfQVAVY+pakP7papapapBYBWQ3+i+I4H5qrrBunZvBK8t2UdQ7hQv/djstAEt\nkJIjqHAFqnHSqDrgbOAl4ArgTQBLxPJFZCzgVdUPaDnpW03I8wCfH9FJE/cOl25RXpcoKp02wMV2\nqpw2oAXSegTVX0Qa0jZ8BTPayVHVfwG3A8NC2j6DCaB8GkBVDwBVInIFgIhkiUi4TmPvAmNF5ETr\n2kimeJ0jaOsEu502wMV2knkE1SW/eHbkedEcJlyBKgemiMgaoCtmKve69fs84I6Qts9h0qD+NeTY\n9cBtVvvFQO9wbqqqu4BbgJdFZDUm5ilcOkTQNtEcmDZjQjJ7HrtERzILFESTuNFhwl0kD6rq1EbH\nzm6m7SjgRVXd33BAVT/m83nBPwXmhrT5bsjzcSHP3wDeCNPOUDpGcU2i2Oe0AS5xYZvTBrRC2AIl\nIrcB38HMRF4J/Xw20faXmLXi/8Zu4vHY6gclIo9gCmR+0c5+oySZR1CHnTbAJS7UtN7EUSL5vN+K\n+SyPBYa31FBV45YPq9UpnqpWqupp4XSmqt9T1ZNUNRmSYyVzcOQhpw1wiQt1ThvQCmGNoERkBjAQ\neBWrak0rfo4zReQa63iliNxr+S6WiUiBdbyHiLxlHX9MRDaKSKuuQEnpSW4T9U4b0ALJXuHYJQr6\neKqPZRJI2qDherxhfd5VdaqIfAEYD0yyjrXk59i4i92qeqaI3Ar8EPgmcA8wR1UfsPq+JRxb0lmg\nknkalcyjO5couSTzIy/G+ThZiTX29kngxxiBuhH4VjPtXrZ+vg9cZT0fhXHuRlXfFJGw1mHTWaCS\nuZqqK1BpyFeOjcqok/rNQYL19QTrAwTrAxIMBAgG6gkGAhIIBAgG6wkGAwSC9RJU63eCBIP1EpQA\nAQIEzUNUggQlQFCCBD1B1BMU9VjPvUHUq+aRoZDR8BPUp2Y65wMyAR+CYHwNo8aKJGns59gUDWtx\nob6NURXBTWeBckdQLgmlA1kd0azjPbaTpC5ukGC9B88xG7pq8HP8VYTXLQS+DDwoIhcTZkXmdM4H\nlcwjqGTeYXSJHmfz37eAB08GJjwtVprycwyHe4GLRWQFZndwG6bkWou4IyhncEdQ6Umyx38eDbeh\nquZbT2dyfEWYpvwcb2jiOlR1OTDO+rUauERV662olPGq2qpbhjuCcgbfo1PnJLMjqUt09HTagBao\nySsZHfbusYjcJiLlViaShmOPACXAr0RkuIg8HMH9+wPLrIiQh2l+gf040nkElcwCBSZzQ3OLjC6p\nST+nDWiBSGM/bwUubcgkAsbPsVGb5Y0vEpEMVf2ci48VTRLxDmc6j6CSeYoHcKLTBrjYTuOirMlE\n2OXNQh01ReQuEVksIiutn6dYbf6XsltE/CLyuIj8B3hGRBaIyLCQ/haJyNBojE7nEVTSCJQGD+8O\nBnZt0/rtB4KB7XUa2JsF2u/z4YkuKc4pThvQAmELVCNHzVpgurV2dCFwP3B1E5edBYxS1aMiMgW4\nAbhdRAYDWaq6Jhqj01mgEhq4qcGj+4OBXVs0sH1/sH5HnQb2ZGrwYC7U9cNk92zs1u9O79KI6ZMn\ntT+96/iN3bP6be7k69o505OdJyLJlJMs2s9DDlAqIidjnCaaC5d5VVUbFuFfAO4WkR8BNxFD2fW0\nFahpMybseHTqnCPYuGOmWnNA63dtCQZ27AvWb6/VwG6f6sEctLYvJg1NbgTdJXvNPpfIOG313nfG\nhh7I8rTf3S2775Ye2SdUd8vqQydft05ZnuwTRDxOpKPeEuV1vwLeUdUrRSSfkAwkjfjfjEVVj4jI\nW8DlGN+nFoONWyJtBcqikgiFQLX2sAb2VAXrt+8NBnbUaGBXhgYPdDYipN2xLxFe0fTJk7x3zno9\nJu9el6ShqPGBmuCR7luPfNJ965FPjjue6Wm3t1tWn6oe2Sfs75bVl86Z3Tpledr1FfH0iqN90QpU\nTsi1N0Rw3ZPAa8CCCFN1H0e6C9QGmhAo1fpjGthTFQzs2KP1248GA7u8GqzuhNb0Bu1NYtYSOmN2\nNT63E+KSkowMt2Ft8GjXbUc/7brt6KfHHfd5sqq7ZvXZ1DP7hP3dsvoFO/u6dczytu/rEU8fG+zb\nFOV1v8FM8X5ABJWwVfV9ETmAlVk3WtJaoIL1O8uCgV09NLD9aLB+p0eD+zugx3qB9gFOsh5OMh5X\noNKFMbF2UBesydlxtLJox9HK4477JPNAl6w+m3tk5+3rntUv0Dmze4dsb4c+gvRtKNUWBhGlQApx\nuNwNDA45dbd1fi7WdE9V/Y2vF5G+GC+B/0Ry38aktUDVHnx2K81n/kwGxgO/ddoIl9iYPnlSb47/\nENtKndZ23nls45CdxzYedzxDfIe6ZPXe1CM7b2/3rLxATmb39tneDr0FT14j4arHZLBNCCLyDeA+\n4AdWxaaoSWuBwuRST2ZGTZ88KePOWa8nc+4ql9a5yImb1mtdx13HNp+669jxqdC9knGkS2bvTT2y\n8/Z0z+5X39HXtfrU6ZcnLJmeqj6DCSqOmXQXqGSvPdcJ4z/yntOGuMTExU4bEEpA69vvrqkq2F1T\nZSLg4OVTudxhq6IjnT3JuXPW61tp+BclL8mQv90lSqZPnpSBic5PZlY7bUC0pLVAWST7KOo6pw1w\niYkLSf4isVF5cScDbUGgkn36NHj65ElnOm2ES3R4Mk4cS/KP0l2BSmLmOm1AGHzDaQNcIufRqXM6\nZHa68rtZubdlZ7S/YIl4cpa8w28RAAAgAElEQVSQfKWn9mD8AVOStiBQ80j+Kipfnz55UqbTRrhE\nzNVAR5GMrIys00dm5dw8Mivn1mPe7HMWItmrSI6EvwvunPV6MtgRFWkvUHfOen0/sMppO1qhG6To\nNkvb5nOlk8STneNrd/6o7Nxbh2V1/uZ2b+Zp8yDDyTqR88NtKCKL42lINKS7m0EDc4FkX+e5ExMF\n7pICPDp1zjnA+S21EW/nPr4OF/fxdbiYYP2Oj+uPLd4SrKs82aTaSRhhC5SqnhdPQ6Ih7UdQFu84\nbUAYnDN98iRHHP5couIHkTT2ZPQ6ObPjleOycm/v6+twxWrx9l4A7G/1wtiIaPYgIodCnv/Yqgy8\nWkRKrGODRORNEXnfSkpXEAebj6OtjKAWYGp0eZ02pBXuBt5y2giXlnl06pzBwDXRXCsi4s0ceLo3\ncyCqgdpA7YdLA8eWBTRYfQaQba+lzIkmW4aIXApcAZxjpU7pap16HJiqqh+LyDnAn4hz1sU2MYK6\nc9br1UDSlqQOYfT0yZPGtt7MxWF+ig2fHRFvZkbW0LOzcm4+Nyvn1hpv9siFSLuV2Lep8+8or7sQ\neFpVjwCo6l4R6QicB7wgIquAxwA7siy0SFsZQYGZ5kWdOCuB3I3ZeXRJQh6dOqcA+Jrd/ZrF9fNG\n+dqdhwYPbKs/+t5Hgdry3lAfS+qfaDMJCJ/fgfQA+1V1WBPt40abGEFZhJ3LxmEumD550jinjXBp\nlt8R5y928XTu4+tw0djsLredktnp6+s9voFzwVMVYTfr7pz1emWUJvwHuElE2gOISFdVPQBsEJFr\nrWMiIqdH2X/YtDWBiveipF380Yrxckki3h5343hUz03kPT0ZPQdldrxiXFbu9/v5Ol5ZJt4+84F9\nYVz6YrT3VNU3gVeB5dZ07ofWqa8BN1u17T4kAa4xopqyPlwRM33ypL9gkrgnPYLnjh/MevX/OW2H\ni6G8oDALKKvL6NB9TdG3y6o7DzwfEUc2XVQDdYHatSvN4vr+YUC7JpoNvXPW62WJts1u2ppAXUSM\nGf4SwSmdRywe2nVcH494xuaVjN7c+hUu8aa8oPDnmAICABzoNOCj1UNvPVLn65jQNZnGqNYcDBxb\nubq+ZlV79MgwzKyo/M5Zr6dFUY6km0aIyG3Ad4DewIOqWmJj93OAHUA8k9NHTSdf143je39ld7uM\njg0OczOAiU7a5ALlBYWFmJ27/9H54MbBoxfdxeZ+4979+KSrBiDevk7YJpLVKaPdyFEZ7UaiwYM7\n6o8trQjWbXrNCVviQdKNoESkgkYllxudb7K0crhMnzzpYaBxCWdHETx1Z/f44uIBHU49R0Qa+8Lc\nklcy+glHDHOhvKAwE5MRo9mRUsCTeWRt4TeW7eo+7Bw+//9LNAqcNG3GhISl+I0nSbVI3qjk8h0i\n8kfr+EwReUhE3gEeFJEOIvKUiCyzSjJHslgXU5UJu+nTbuDqqwfcsSm/45CxTYgTwMNVxQuiKhvt\nYgv304I4AXiDte2LPnxy7Mil/t3ZR3cvSZBdzbEwXcQJknMEVYnxV5oEDFfV74rITExl3stVNSAi\n9wNrVfVZEckFlgJnqGpY5c6nT560AlPyyTEyPdn7xvWe/EFuZq9RYVTm+AgYnlcy+mAibHMxlBcU\nfgn4J8YvKGx2dh+2Ym3hlM5Bb6YTVYO+OW3GhL84cN+4kFQjqFZ4QVUb3PYvBoqtLdC5mBCB/hH0\n5eg/sDDn3IVX9L8t0CWr9+gwywYNxoQZuCSI8oLCfKCUCMUJoOfuVWeOWXhnfl7V3PmoJjKZ3RHg\n7wm8X9xJJYEKHR0JcLWqDrMe/VU1kgouzwPH7DWvdXJ83Tdc3v97K4d2HTNKRCItf31dVfGC2+Ni\nmMtxlBcUdgJeAbpE24dHgxmDP3lhzKjFP6nrdGDjAmIsvxQmz0+bMSGtRtmpJFCh/Bv4XsPoQ0Qi\nmq7dOev1fcBf42FYU3jw1pzX8/J5l/S7qW+2t30sU8vpVcULrrLNMJfPUV5QmIFxcrTFfSCz7mD3\nESt+M/rMlQ+ty6g7Ek+/JAUeimP/jpCqAvUrwAesEZEPCPFPiYAHMBkO4kq/9oNXXpV/+9YTOhSM\nFZGsGLvzAM9VFS8YZYdtLsdTVFokq06UXxOHMlK5Bz4tHLPoR0WD1v9jMRrcbnf/wJvTZkxI9jqQ\nEZN0i+SJZPrkSc8BX41H31me9rvH9bluXW5mjxaTmkVJNTAur2R0smcKTSmKSov+ANz2k1mBeWd8\nqnHLKlHvzTr04ak3Lt/T9bTzELEr1fOF02ZMeNumvpKGti5QpwIfEMVCaAvoabmjF52ae+4QEYl6\nDSMMdgKXuCJlD0WlRb8Cft7w+7feCMy7cJWOEXvfG8dxuH2vjauGfndnTXbXETF2tXLajAlRZYwV\nkduBxxtSq0Rx/UzgdVWNOvavxf7bskABTJ886UVM8vuYyc3suX587+sOZ3rbJcpvqRr4Ul7J6AUJ\nul/aUVRaJJi1m89tQFy5KLjwuvnBkRLniIvtvUYsLz/l693Uk3FilF1cM23GhJeiubDBrUdVd0d5\n/UziKFCpugZlJ7+OtQOvZBwd1evquRf3vaF/AsUJIAf4d1XxgkkJvGfaUFRalIFxJWhyd/SV8z2j\n/jTJs1LN9n3c6L1j2fCxC+7I67N10TxUI92FWwu8HE5Dy8F5tpXG9wMRuQfoC7xjOUEjIheLyLsi\nskJEXrAS1SEiZ4nIPCvd779FJO7J6sAdQQEwffKkV4EvRXNt/w6Fy8/pMbGnR7yR+GHZTT1wc17J\n6GcctCGlKCotysHs1l3YWtuhnwbLfjYreIJAbrztqsnM2bl66K0fH+rQ7zzC85H72rQZE54Pp28R\nuRr4gqp+y/o9B1MWfbiq7rZcX17GhJodFpG7gCzMhtI8jKP0LhGZDFyiqje5I6jEEPEuYLa3485L\n8761+Nyelw13WJzATEFKq4oXPFhVvCDZ8647TlFpUT6wmDDECWDNQE9R8Y3e3QFhW1wNA7Jqq3ue\nvfyB84etfnitt/7Y2laaVwCzIui+DLhQRB4UkdH6eSfSkcCpwCLLCXoKMAA4BTgNeMs6/nMgL4L7\nRo0rUMCds15fRvj5m4Ondxk3/7ITbs3q7OuabGV6frzJs/spv9/f02lDkpWi0qLLgPcxH8Sw2dBb\nTvr+VG+wzpuYKr1d9380ZMzCOwvzK2cvRIO7mmn2o2kzJoTtKqOqHwFnYYTqARH5RaMmArwV4gB9\nqqrebB3/MOR4kara7orRFK5AfcYvaKUSbNesPuuuGnB7eUHuOWOs4XFScZTa3W/5Vl8ErPb7/W4J\nq1D8OVlnPz2kBBNb17W15k2xM1f6fWeat/PRTFob2diCgAys/NeoMQt/lNVlb8U8VOtCTv932owJ\nr0fUn0hf4IiqPotJXXwmcBDoZDVZApwvIidZ7duLyGBgHdBDRM61jvtEZEhsry48XIGyuHPW60uB\nmU2d84rv8JheX553YZ/rB/k8WQn5x0SKosGXspZsUqEPJpfWv/1+/4N+v9/ntG2O488ZBiz//r79\nY2Lt6kAH6fbt73n77+/A+zZYFhYZgWOdz1jzyNizl9+/ObOm+n1M1ZeI6vJZFAFLrWnazzAbRI8D\nb4jIO6q6C7gB+KuIrMEIVoGq1mLKbD1opftdhanwEnfcRfIQpk+e1AOTOeB/i6H5HU9bOqL7pf08\n4klkNdiIecu3Zu5G765xTZxaAXzP7/cnXVnruOPPyQR+jBkd+wCu7dt7YUVWZsye+BkBrf3tk4Hl\n/fYm5oMayo6eZ903bv6zP2+9ZerjClQjpk+eNA34Y3tvp23j+3x1Y0df7kinbWqNjz3bls3zrR2O\ntOhU+Bxwl9/v35IouxzFn/MljH/TcSlPDoscGjUgb0+9yICY76Gq/ucC80/dTCJrGe4CCgoryvcm\n8J6O4QpUI6ZPnuQt6jLmmcKckV8SkU6tX+EsB+RI1d8z3+2AhBV5fxh4EPi93+8/1FrjlMSfcwZQ\nQgvxdMuys9be1LvnyYjYMv297Z+BeaPWxi80phE3FVaUJ1XSxXjiClQTVBUvOAuT5jWpt+wDBGue\nzZq/vk4CkSbI340Rqkf9fv/ROJiWePw5J2HcRSYTRnjKT7t3nftap47j7Lr9V98JzL98iY6S+K7r\nLgJGF1aUt5kPrStQzVBVvOC3fFYPLCl5NXPZ/J2eA7Es/G7HCNVMv9+fKjUDj8efMw7jCf4lIhCH\nIATH9u+3Zr/Xa1tVlovfDy65+T/BM8Q4N9pNPXBWYUX5mjj0nbS4AtUMVcUL2mH8RQY5bUtTrPZW\nLlrmW29XpoRjGA/iJ4G5fr8/qd8U+cWzOwNf+773pdF3+F76SrT9bM3wbvtCXt92atJG28KIdcGV\nP3w5OEigs119WtxdWFEec1hWquEKVAtUFS8YiylVlVTuGLvkwMf/zFzWD6G93X3n5m57q2jof98D\nXrhgwvqk+bbOL57dDrgIE9h9DdA+m5qja7NuPOYJb/2tSZ7v1PHdB7p3tbVa8OAqrfjls4FuHqWH\nTV0uBMYWVpQnIitnUuEKVCtUFS/4BXCv03Y0UEv9wWez5u8OikYb+d4iQ09/c35Ozq6GaeM64CXg\nHeDdCyasD6sohV3kF88eiBGlS6zH5wT5Gd8D88Z4y2JaoP5y394Ly21wPQil327d+Nu/BDwZQU6I\nsatq4PTCivKNdtiVargC1QpVxQs8wJuYD4rj/D1z8bsHPEdt/cZvQCRYd/6o5w6I0K2J0/UYn6rF\n1s+VQPkFE9bbkpW0318W5Po+PnAGJtXuGcD5mBJkLXKibN00J/OHeSLRj3KPiBweNSBvZ52IraLf\n5aDufHhGYF9WPafE0M3XCyvKn7PNqBTDFagwqCpe0BPjPZuQFBPNsShj3bzyjKq4bWf36vXJssGn\nvBtJ8rSjGMfWbcBWYOuNPL+1VrIOYb75qzE7apmYheMsjBNsF+tnH0wg6ilyoHZf1ru7oirTtCRr\n2rLesi+mpG/Ls7PW3mij60ED7Y9p9SN/DlR2OsbpUVw+s7Ci/EY77Uk1XIEKk6riBWMw61GOuB5U\nefaUvelbVYAQt9CVs4b/49327Q9GPToLIsHreUERifxvFNS6rLe2qhgxi4irPPOXPZQ5I9aslNzd\nvevcf9joetCAr16P/f7xwOqe1ZwTwWVrgJGFFeURuYGIiB84pKq/i+S6ZCWpFn+TmbyS0fMxIRMJ\n5yi1u//tW9U9nuLk9dYeaNfuYExb7ofouD8qcQLwiA8PUa2zvBIcdVadejdHdd8Q7t29d0yXQGBl\nrP00pi5Dsm+b6h3+aW/CzXx6ALgmUnFqDhGJa0bQeOIKVGQ8gFmPShiNgoDjRt9+FWtEaBdLH/vp\nGlORSs3OiCrtrOLxvBQYvT6WewN4wDNry/beorov1r4aE/SIt/jGjNHLT5K5YTS/ubCi/ONw+xaR\nn4nIOhH5L2bKjIjMFZH7RWQe8H0R+ZKIvCciK0XkvyLSy2rXQ0TesjJoPiYiGxtqNorID6zMmx9Y\nucsRkXwRKReRJ0TkQxH5j4jE9L5pCVegIiCvZLQC10NicgIB/Ne3Zv4xqYsqIX4k9O27rkOsfeyl\na0xFIzXHVxvttQ/WXzdUNfZirH0CgT4/27NvXaz9NMdvrvWOe/NMmafNp/Z5oLCiPOzslCJyFnAd\nZmPhKiB0qpurqmNVdTrGVWGkqp4B/A0TRA1wDzBHVc/EFCvtH9LvjcA5mER23wqpP3ky8KiqDgH2\nY1NO/6ZwBSpC8kpG7wYuBeIerPmRZ9uyjZ7dcY/xysw8vN3nOxbNIu5x7KF7TFOSYJesqL+J99G5\na7n2tyUFyuSDh0aeWlMTt0IUT13iHfvceM9ihbpGp57FpEGJhNHAK6p6RFUPAK+GnAvNtpkH/FtE\nyoAfAQ1pg0ZhBAtVfRPYF3L8FVU9rKqHMI68o61zG1S1oZrQ+0B+hDaHjStQUZBXMnodcBlxLJ9e\nLUeq5vvWntxKhgJb6D9gzbpYtukb2EP3qEdAAMEumb1iuf7eum/YVubr6W07z/Spxm2k/OpIz/mP\nXOZZHVKQ4W1MIHA0u1bNXRPqt/YI8EdVLQK+DWRbx5t7f7X0vqsJeR4gjlVvXIGKkryS0Ysw0z3b\nvXsDBGteyVx6EIl/kn6Anj032LK+tYfuMf0ttEPGCWpcF6LiPT311EOabUu2y/aqHZ7YtvNYoyyW\ntrJwiGf4r6/zfFrvYSFwVWFFeTT3mg9cKSLtrOwbzRX/yAEaUu1MCTUD+DKYii7wP6/8+cAVVlbN\nDsCVEPYiv224AhUDeSWjXwRutbvf1zPfX1ovgUK7+22Kjh33fOz1Bgbb0de+6DLpfoaIB6/E5DE9\no/5Ltk29z6qpKbzy0OG4JvorO9HT/qt3ZUwurCg/EM31qroCM5VbhfH6b05E/MALIrIAk82igXuB\ni0VkBWbpYhtw0Op3JrAUk9njSVW1fYezNVw/qBCi9SGpKl5QjNnhi5lV3g0Ll/s+tTXsoiWGDJkz\nr2u3Lbasc93F7xdVSf+YApgzF+1Y5DlUH3UfWdQeK8+68YhHNEa1NCjouP79Vu71euOxUbEFGF02\npSxhmy6NEZEsIKCq9VbO8T+rqm0ZHmIlrUdQYoj7a8wrGV0C/CbWfnbJgY+XZ3x6lg0mhYlql65b\no/LebopDdIw5zUgwJ7M+lutryMxeECyyLchZQGZt2d5XVO3eFNkNXOSkOFn0B5ZZucYfBr7lsD3H\nkXYCFeKn8SdMzNj1IlJm+XI8GNLuC5bvx2oRebuJfr4lIm+E6+ORVzL6LuD+aO2upf7Aa5nLfcTo\nixQJXbtWrRFR23KtH6NdzNkVgl2zYnZ3uKd+yiBV+9YGewcCve/eszdsv6Qw2A9cUjalrNzGPqNC\nVT9W1TNU9XRVHaGqy5y2KZS0EyiLU4BngImYLIsTMEGoI0TkChHpATwBXK2qpwPXhl4sIt/FLDZe\noaphL9rmlYz+GabaRsTz5lcyl64NiuZHel0s9B9QFtW6R3PU4ou5FJfmZvaNtY9K7XPCdrraWnXl\n2oOHzznNHteD7cC4sillK2zoK+1JV4HaqKpLME5rc1V1l6rWYwoHjME4ns1XaxtZjx++X49ZLLxa\nVWuIkLyS0b/HOLiFPVVZmFEx76DnaEKLM4gEajp23DPUzj6DeGPeddT2GX3VhHrExIN119nunvHU\ntp1nZap+GkMXnwKjyqaUrbbLpnQnXQWqwf+jJR+P5kY5H2Acz6Iu7ZxXMroU413bqp/UZs/uNRXe\nLXZlxgyb3r0/WSmCbcVHa8g8itmOjp0M2RRrF/8Inn9WnXpj7ieUdqrt/7JtRy2mTlykrAHOL5tS\nFnNITlsiXQWqgfeAsSLSXUwQ61eAecC71vETAUQkdMdnJcaR7VWrEmtU5JWMfhX4Ai2MBo5Qs+s/\nvtU9kfg5ujVH3gkf2jrCOECObfFr2j7Dhr5EXgyMsX0BelhNbcHVBw+/G+Fl7wBjy6aUbbfbnnQn\nrQVKVbcBP8G8QVYDK1T1n1YF1VuAl63di1mNrluIKZgwuyFwMhrySkbPA8YBOxufC6KBl7Peq1Kh\nd7T9R0tGRs3+rKzDZ7TeMnz20s229axgbqYtvi9WfJ7tVWvu2bN3TNdAINw1pJmYBfHULErhMK4f\nVAKoKl4wABPL9D9fmv/4Vs/d5N09zgl78vNXLjih/wejW28ZPu9y/vt/lB/Y4iLh2X50ZebqvbYI\n6OzMnywc4tlou1/Zdq93+8Un9PWpSFPZR8EsIfy8bEpZ1Du7Lmk+gkoW8kpGb8SksC0FWOfdunRT\nAoKAm6N3n49sW3tqYDfdI95QaI5gl8xY83j/D3/dlOYEJCZ6BwK9/bv3NreedBj4SqziZKVMGR5j\nH7kiYnu0Q6JwBSpB5JWMPpZXMvqGo9ROXZBRnp+IIOCmyM4+WJWRUVtkd7976G5fzFqWt7vCHju6\nWqYFhQe13Yd29NWYqw4dPnvosZr5jQ6XASPKppTNauoaB8glDuFYicIVqARzcskFjyFMIoE5pULp\nP2D1eomDOO5tss5CDPg8VXZ1NaP+S7YnoGvgL9t3jsgMasNI6gngnGgcMEXkbhGpsJLH/VVEGorG\nXisiS0XkIxEZbbXNFpGnLQfklSIy3jo+xGq7SkTWiMjJmDLwg6xjv7XhJScUV6AcwO/3L8MkGHs5\n0ffu0WNj1O4TLbGfLraKnnbIiCk7ZyhPBCaOCKrYMiJrTLZquye279yPmdLdUjalLOJFeWsadzWf\nJZ0LndZlqOrZmOrJ91jHpgFYqVO+ApSKSDYwFfiDFUs3HKgCioH1qjpMVX8U1Yt0EFegHMLv91f7\n/f6rMakv4p78DqBz550VHk8wLpWSD9I54mIHLRHMzbRN8GrxZc0Nnl5mV3+NePvMmpory6aU/S2G\nPkYB/1TVo6p6EHgt5FzDl1hoYrhRwP8BqGoFsBEYjHGf+amI3AUMiCQKIllxBcph/H7/M8CpmFQZ\ncaX/gNU74tX3ETrYGkMY7Jplay6se+u/cZKd8XmYvFXfBy7CXx1rwYZwksOFJoZrsr2qPo9JpHgU\nkz1zQox2OY4rUEmA3+/f4ff7r8GU9I6TiGgwN3dHQXz6hhqyOtrZXzA3s7+d/W3U3nnb6Lrcpu6W\nAWfir34Yf7UdfjoLgS9Za0sdMTGkLTEf+BqAiAzGZCRYJyIDgU9V9WFM6t+hwEGgkw02OoIrUEmE\n3+9/CTOaesbuvrt337hKRGNKqdsS9WTY67rg8+SoCay1jQfrvhLr+73BwXck/uoKG0wCwMog8CrG\nmfhlYDmm6Glz/AnwWvnFZwE3WHGjk4EPRGQVUAA8o6p7gEVWNo+UWyR3HTWTFL/ffwHwEOZbMGbO\nPPO1RR067o9LzF9MBTtbIOudbe9LbdDG/FiqH2V9Y1OmBAZEeGE98EfgXvzVcfEIF5GOqnpIRNpj\nRki3WFkt2zTuCCpJ8fv9b2N2db5FjCMJj6f+SPsO+23NXBBKTAU7WyDYyXfI3h5FXgiMrYzwojeB\nofir74iXOFk8bo18VgAvueJkcEdQKYDf7+8I3IGJD+wc6fX9+q1dPHDQ++fZbpjFJgZs+Ik8dKLd\n/Xo/ObDQt/6grWEqORzavyrrlqwwipS+BxTjr55r5/1dIsMdQaUAfr//kN/v/xUwEJhOhJVP+uWV\nx61kOsResLM5tGuWLXnFQ6mmY+6Hmt/SYnk5cBX+6pGuODmPK1AphN/v3+P3+38InAD8gjB2/Hy+\no7szM4/YmrmgMbEW7GyOYGffgBYq8EaNv25KUxkqVgBfB4rwV79i9z1dosMVqBTEEqpfAQOAbwLN\n1oI74YQP1kqc803FWrCzWTI8HRBsC3lpYLmeUnhA232A8S16GRiDv/os/NXP4a8ORNOniPhDwlNs\nb99WcQWqGUSkMppcUCIyTkSaXe8RkctEpDg26wx+v7/G7/f/BTgN+CKmOu1x9Oq9Pi7R/KHEWrCz\nRbK82+LQ6+7f1U9+HjgJf/XV+KsTWpBSRBKeoDBVcf9Q9jMOOAR8ruCjiGSo6qsYnxfb8Pv9CrwB\nvOH3+wdjwmeub9euOpiRUTfEzns1RcwFO1sg2Ml31HssqkFNYxSYgwnofeWX9/2hFv4QU4ci8jPg\nG8BmjI/U+yLyLYyvVCbwCXC9qh4RkZmYkKYzMNPJgyH9fAsTg3dVOoSn2Im7iweIyNeB2zBvqvcw\n6SnWA8NVdXdT51U1ICJfwJSa8mLqnN0MLMFMHXYB37OOhb4xy6x+vysivYAZmMVvgO+oqi2VbP1+\nv2fQoKWj+vZbNwXz5o9bGXU7CnY2h3fDwcW+jw7EsgNZgQkjerqyZKJt+cBF5CxMtsxzMF/0KzD/\ny6ct50hE5NfADlV9xBKo7sDl1nvHj/kiOwZcDFwbTZGOdKfNj6BEpBDjgXu+qtZZ9fS+1tp5EXkD\n8208RlU3iEhXVd0rIjMIqU4sIjdjAjkvtN6YN4Tc/mFgnqpeaeVMty1cxO/3BzEOf/PfnjPoVuAS\nYBKmYo2tGQ3sKNjZHMEuWZFOs4OYL4l/AP+sLJn4kf1WATAaeEVVjwCISMOo+DRLmHIx/89/h1zz\ngqqGDgevx2QcuEJV7cunlUa0eYECLgDOwlRXBWjH8TnEmzvfUumqxjR+YzYwATNFwDpvW4qRUC6Y\nsL4GM618FeDtOYNOwwjVFzGZPmNyQ7CjYGdzaCffAIWAmFFqc2wD3rIe/6ksmfi5HPBxoqnpx0yM\n4Ky2vozGhZw73KjtB5h6jXk4lB8s2XEFykSGl6rqT447+NlIp7nzlxH+FnjjN6ajXDBh/QeYD8dv\n354zqBNGpM6zfo4gwuBSOwp2NotXshA2oIQ6gm7EVN+ZD7xVWTLxg7jdv3nmAzNFpATzOfoS8Bjm\nb7dNRHyYkfiWFvpYCfwZU0HoElXdGmebUw5XoMzO1z9F5PequtMqQdUpjPPvAo+KyImhUzzM4me4\n3t5vA98B/p81xeugqrZW+22NCyasP4gJ53gT4O05gzyYyszDMd/ug4GTMetkTY607CjY2QxHgArt\n7Jsj1XXbgFXAqsqSiQnJn9USqrpCRGZZNm0EGnYC78asU27ErDe2KPaqutByN5gtIhep6u44mp1y\nuIvkgIhMxpSn8gB1mIyFf+OzRfLPnVfVJSJyKWaR3APsVNWLrPQXL2LWQhoWyV9X1Rete93A8Yvk\nj2M+/AHMInmkNdcSwttzBnmBEzFidTLQD+hVj7f7FPl7L6Ab0AXoQMtTRsV4wh+wHnsxo4yqkJ9V\nwCZg0/bxw9w3aBvGFSiXuND7nVUZmBG6j89G6keBGld0XMLFFSiXtEZEbsNMo3sDD6pqSQttxwE/\nVNVJTZy7HXg8ZNfuX8BXVdUtyBlH3DUol3TnVuDSht3WGLgdeBazLoaqfjFWw1xaxw11SVFE5EkR\nOdVpO5IZyydtIGaX7OQEDawAAAQHSURBVA4R+aN1fJCILBGRZSLySxEJzTvVUURetEpAPSeG24C+\nwDsi8o7VR6WIdBeRfBEpF5EnRORDEfmPiLSz2oywyj+9KyK/FREndhtTGlegUhRV/aaqNhsk7AKq\nOhXYCowHQmvj/QFTnmmEdT6UMzCjpVMx4na+leN7KzBeVcc3cauTgUdVdQiwH1NCCuBpYKqqnovZ\nBHGJEFegkgTrm7hCREqtb90XRaS9iFwgpjhjmYg8JSJZVvu5IjJcRLwiMtPKOV0mIndY54dZo4Q1\nIvKKiHQJue5BaVQMso1xLrBTRF4Hnm90bqmqVqlqEONCkB9GfxtUdZX1/H0gX0RygU4hoUuN7+MS\nBq5AJRenYBZih2K24H+A8UyebBVpzMAs+IYyDOinqqdZbZ62jj8D3GX1VcZnRR+h6WKQSYdDUf+h\n8XChpZ4ivcaR0vbphitQycVmVV1kPX8WE2azQVUb4slKgTGNrvkUGCgij1jBywdEJAfIVdV5zVzX\nVDHIhCNNlPu2Rnj3i8g84PsiMkBE3rZGgm+LSH/r2pkick1IX4esn+OsPl4UkQpMgG4D/a1jgkmf\nDHBdmOZGVL5JVfcBB0VkZIT3cQnB3cVLLiL2+VDVfSJyOiYYeBrwZUz+8pZoqhhkQpHjy303ZAN4\n3zqdq6pjrXavYconlYrITZgA6yta6f4MYAhm3egIJuOAD7MWdabVZgnmC3oZ4cVAPg68ISLbmlmH\naoqbgSdE5DAwN8z7uITgjqCSi/4icq71/CvAfzHrGSdZx64H5oVeICapnkdVX8KEWZypqtXAvpD1\npc9dlwS0VO57Vsjzc/ls/eb/rOtaI3Qd6WmMh/syYKWqfozxWL8RWASsw9ShQ1XnhvpAqep3VXWm\n9fwRVS1oECdVzVfV3apaqaqnhVzzO1X1W79+qKpDrUXy6ob7uISPO4JKLsqBKSLyGPAxprT2EuAF\naz1mGSbnUCj9gKdFpOHLpiGoeQowQ0ydtU8xH8hkoqU1mpaCqxtGmfVYX7AiIphcXQ00t47UcO1Z\nmJ28bpi4yZvCMzliJorIT6z7bwRuiNN90hZXoJKLoLU1HkpDfbzjUNVxIb+e2cT5VZiUMM1eZwWm\n5kdnaswsBB4TkQcw78OJmPxajVmMWb/5P0x2gIXW8UqM0PwduJzWU8ZUACeKyCBVXSAiSzC7bJ/z\nGrcLVZ3F8aNBlwhxp3gujhBBue/bgBtFZA1mqvp96/gTwFgRWYpZY2oxpY2qHsOk4p0tIgsxIxqX\nJMeNxXNxDHHLfbu0gjvFc3GSx61wnWxMUkBXnFyOwx1Bubi4JC3uGpSLi0vS4gqUi4tL0uIKlIuL\nS9LiCpSLi0vS4gqUi4tL0uIKlIuLS9Ly/wEFasTwJDil9gAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# donuts charts\n", - "sorted_counts = df['type_1'].value_counts()\n", - "plt.pie(sorted_counts, labels = sorted_counts.index, startangle = 0,\n", - " counterclock = True, wedgeprops = {'width' : 0.4});\n", - "plt.axis('square') # this will make the results a circle" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Histograms" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngS5JjTDQJakRBrokNeL/AUbdOuaioYuMAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "bin_edges = np.arange(0, df['speed'].max()+5, 5);\n", - "plt.hist(data = df, x = 'speed', bins = bin_edges);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Subplots" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlMAAAEyCAYAAADeAVWKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCgBghP8LsvDYiRkRZY4AAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=[10,5])\n", - "plt.subplot(1,2,1)\n", - "bin_edges = np.arange(0,df['speed'].max() + 5, 5);\n", - "plt.hist(data=df, x='speed', bins=bin_edges);\n", - "# hist on right\n", - "plt.subplot(1,2,2)\n", - "bin_edges = np.arange(0, df['speed'].max() +1, 1);\n", - "plt.hist(data=df, x='speed', bins=bin_edges);\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Alternative Approach" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 82, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEKCAYAAAASByJ7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sb.distplot(df['speed'])\n", - "#The distplot function has built-in rules for specifying histogram bins, and by default plots a kernel density estimate (KDE) on top of the data.\n", - "# The vertical axis is based on the KDE, rather than the histogram: you shouldn't expect the total heights of the bars to equal 1, but the area under the curve should equal 1" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEKCAYAAAACS67iAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJHXi/wF9YLtNHcCLLwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "bin_edges = np.arange(0, df['speed'].max()+5, 5)\n", - "sb.distplot(df['speed'], bins = bin_edges, kde = False,\n", - " hist_kws = {'alpha' : 1})\n", - "# This approach is not necessary, it can be simply done by hist" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Choosing a Plot for Discrete Data\n", - "## Descriptive Statistics, Outliers, and Axis Limits" - ] - }, - { - "cell_type": "code", - "execution_count": 92, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0, 35)" - ] - }, - "execution_count": 92, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAAEyCAYAAAAvCg4HAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSZUZuCRJkiozcEmSJFX2/wCGBG2srSZa7gAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize = [10, 5])\n", - "\n", - "# histogram on left: full data\n", - "plt.subplot(1, 2, 1)\n", - "bin_edges = np.arange(0, df['weight'].max()+5, 5)\n", - "plt.hist(data = df, x = 'weight', bins = bin_edges)\n", - "\n", - "# histogram on right: focus in on bulk of data < 35\n", - "plt.subplot(1, 2, 2)\n", - "bin_edges = np.arange(0, 35+1, 1)\n", - "plt.hist(data = df, x = 'weight', bins = bin_edges)\n", - "plt.xlim(0, 35) # could also be called as plt.xlim((0, 35))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [default]", - "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.6.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} +{"cells":[{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["import numpy as np\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","import seaborn as sb\n","\n","%matplotlib inline"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["pokeman = pd.read_csv('pokemon.csv')\n","print(pokeman.shape)\n","pokeman.head(5)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["sb.countplot(data=pokeman, y='type_1')"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["base_color = sb.color_palette()[1]"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["sb.countplot(data=pokeman, x='type_2', color=base_color)\n","plt.xticks(rotation=90)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Absolute vs. Relative Frequency\n","# By default, seaborn's countplot function will summarize and plot the data in terms of absolute frequency, or pure counts\n","#One method of plotting the data in terms of relative frequency on a bar chart is to just relabel the counts axis in terms of proportions. \n","n_points = pokeman.shape[0]\n","\n","max_count = pokeman['type_1'].value_counts().max()\n","max_prop = max_count / n_points\n","# generate tick mark location and names\n","tick_props = np.arange(0, max_prop, 0.05)\n","tick_names = ['{:0.2f}'.format(v) for v in tick_props]\n","\n","# create the plot\n","base_color = sb.color_palette()[2]\n","sb.countplot(data=pokeman, x='type_1', color=base_color)\n","plt.xticks(rotation=90)\n","plt.yticks(tick_props*n_points, tick_names)\n","plt.ylabel('proportion')"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Rather than plotting the data on a relative frequency scale, you might use text annotations to label the frequencies on bars instead\n","\n","base_color = sb.color_palette()[2]\n","sb.countplot(data=pokeman, x='type_1', color=base_color)\n","n_points = pokeman.shape[0]\n","type_counts = pokeman['type_1'].value_counts()\n","locs, labels = plt.xticks()\n","for loc, label in zip(locs, labels):\n"," count = type_counts[label.get_text()]\n"," pct_string = '{:0.1f}%'.format(100*count/n_points)\n"," plt.text(loc, count-8, pct_string, ha='center', color='w')\n","plt.xticks(rotation=90)"]},{"cell_type":"markdown","metadata":{},"source":["## Counting missing Data"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["df = pd.read_csv('pokemon.csv')\n","df.head(5)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["na_counts = df.isna().sum()\n","base_color = sb.color_palette()[2]\n","sb.barplot(na_counts.index.values, na_counts, color=base_color)\n","plt.xticks(rotation=90)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# pie charts\n","sorted_counts = df['type_1'].value_counts()\n","plt.pie(sorted_counts, labels = sorted_counts.index, startangle = 0,\n"," counterclock = True);\n","plt.axis('square') # this will make the results a circle"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# donuts charts\n","sorted_counts = df['type_1'].value_counts()\n","plt.pie(sorted_counts, labels = sorted_counts.index, startangle = 0,\n"," counterclock = True, wedgeprops = {'width' : 0.4});\n","plt.axis('square') # this will make the results a circle"]},{"cell_type":"markdown","metadata":{},"source":["## Histograms"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["bin_edges = np.arange(0, df['speed'].max()+5, 5);\n","plt.hist(data = df, x = 'speed', bins = bin_edges);"]},{"cell_type":"markdown","metadata":{},"source":["## Subplots"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["plt.figure(figsize=[10,5])\n","plt.subplot(1,2,1)\n","bin_edges = np.arange(0,df['speed'].max() + 5, 5);\n","plt.hist(data=df, x='speed', bins=bin_edges);\n","# hist on right\n","plt.subplot(1,2,2)\n","bin_edges = np.arange(0, df['speed'].max() +1, 1);\n","plt.hist(data=df, x='speed', bins=bin_edges);\n"]},{"cell_type":"markdown","metadata":{},"source":["## Alternative Approach"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["sb.distplot(df['speed'])\n","#The distplot function has built-in rules for specifying histogram bins, and by default plots a kernel density estimate (KDE) on top of the data.\n","# The vertical axis is based on the KDE, rather than the histogram: you shouldn't expect the total heights of the bars to equal 1, but the area under the curve should equal 1"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["bin_edges = np.arange(0, df['speed'].max()+5, 5)\n","sb.distplot(df['speed'], bins = bin_edges, kde = False,\n"," hist_kws = {'alpha' : 1})\n","# This approach is not necessary, it can be simply done by hist"]},{"cell_type":"markdown","metadata":{},"source":["## Choosing a Plot for Discrete Data\n","## Descriptive Statistics, Outliers, and Axis Limits"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["plt.figure(figsize = [10, 5])\n","\n","# histogram on left: full data\n","plt.subplot(1, 2, 1)\n","bin_edges = np.arange(0, df['weight'].max()+5, 5)\n","plt.hist(data = df, x = 'weight', bins = bin_edges)\n","\n","# histogram on right: focus in on bulk of data < 35\n","plt.subplot(1, 2, 2)\n","bin_edges = np.arange(0, 35+1, 1)\n","plt.hist(data = df, x = 'weight', bins = bin_edges)\n","plt.xlim(0, 35) # could also be called as plt.xlim((0, 35))"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]}],"metadata":{"kernelspec":{"display_name":"Python [default]","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.6.3"}},"nbformat":4,"nbformat_minor":2} \ No newline at end of file diff --git a/Numpy/Mean Normalization-and-Data-Separation .ipynb b/Numpy/Mean Normalization-and-Data-Separation .ipynb index 57fde73..67d621d 100644 --- a/Numpy/Mean Normalization-and-Data-Separation .ipynb +++ b/Numpy/Mean Normalization-and-Data-Separation .ipynb @@ -1,311 +1 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Mean Normalization\n", - "\n", - "In machine learning we use large amounts of data to train our models. Some machine learning algorithms may require that the data is *normalized* in order to work correctly. The idea of normalization, also known as *feature scaling*, is to ensure that all the data is on a similar scale, *i.e.* that all the data takes on a similar range of values. For example, we might have a dataset that has values between 0 and 5,000. By normalizing the data we can make the range of values be between 0 and 1.\n", - "\n", - "In this lab, you will be performing a different kind of feature scaling known as *mean normalization*. Mean normalization will scale the data, but instead of making the values be between 0 and 1, it will distribute the values evenly in some small interval around zero. For example, if we have a dataset that has values between 0 and 5,000, after mean normalization the range of values will be distributed in some small range around 0, for example between -3 to 3. Because the range of values are distributed evenly around zero, this guarantees that the average (mean) of all elements will be zero. Therefore, when you perform *mean normalization* your data will not only be scaled but it will also have an average of zero. \n", - "\n", - "# To Do:\n", - "\n", - "You will start by importing NumPy and creating a rank 2 ndarray of random integers between 0 and 5,000 (inclusive) with 1000 rows and 20 columns. This array will simulate a dataset with a wide range of values. Fill in the code below" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1000, 20)\n" - ] - } - ], - "source": [ - "# import NumPy into Python\n", - "import numpy as np\n", - "\n", - "# Create a 1000 x 20 ndarray with random integers in the half-open interval [0, 5001).\n", - "X = np.random.randint(0, 5001, size=(1000,20))\n", - "\n", - "# print the shape of X\n", - "print(X.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that you created the array we will mean normalize it. We will perform mean normalization using the following equation:\n", - "\n", - "$\\mbox{Norm_Col}_i = \\frac{\\mbox{Col}_i - \\mu_i}{\\sigma_i}$\n", - "\n", - "where $\\mbox{Col}_i$ is the $i$th column of $X$, $\\mu_i$ is average of the values in the $i$th column of $X$, and $\\sigma_i$ is the standard deviation of the values in the $i$th column of $X$. In other words, mean normalization is performed by subtracting from each column of $X$ the average of its values, and then by dividing by the standard deviation of its values. In the space below, you will first calculate the average and standard deviation of each column of $X$. " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Average of the values in each column of X\n", - "ave_cols = X.mean(axis=0)\n", - "\n", - "# Standard Deviation of the values in each column of X\n", - "std_cols = X.std(axis=0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you have done the above calculations correctly, then `ave_cols` and `std_cols`, should both be vectors with shape `(20,)` since $X$ has 20 columns. You can verify this by filling the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(20,)\n", - "(20,)\n" - ] - } - ], - "source": [ - "# Print the shape of ave_cols\n", - "print(ave_cols.shape)\n", - "\n", - "# Print the shape of std_cols\n", - "print(std_cols.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can now take advantage of Broadcasting to calculate the mean normalized version of $X$ in just one line of code using the equation above. Fill in the code below" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1000, 20)\n" - ] - } - ], - "source": [ - "# Mean normalize X\n", - "X_norm = (X - ave_cols) / std_cols\n", - "print(X_norm.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you have performed the mean normalization correctly, then the average of all the elements in $X_{\\tiny{\\mbox{norm}}}$ should be close to zero, and they should be evenly distributed in some small interval around zero. You can verify this by filing the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-1.54543045028e-17\n", - "-1.72906934918\n" - ] - } - ], - "source": [ - "# Print the average of all the values of X_norm\n", - "print(X_norm.mean())\n", - "\n", - "# Print the average of the minimum value in each column of X_norm\n", - "print(X_norm.min(axis=0).mean())\n", - "\n", - "# Print the average of the maximum value in each column of X_norm\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You should note that since $X$ was created using random integers, the above values will vary. \n", - "\n", - "# Data Separation\n", - "\n", - "After the data has been mean normalized, it is customary in machine learnig to split our dataset into three sets:\n", - "\n", - "1. A Training Set\n", - "2. A Cross Validation Set\n", - "3. A Test Set\n", - "\n", - "The dataset is usually divided such that the Training Set contains 60% of the data, the Cross Validation Set contains 20% of the data, and the Test Set contains 20% of the data. \n", - "\n", - "In this part of the lab you will separate `X_norm` into a Training Set, Cross Validation Set, and a Test Set. Each data set will contain rows of `X_norm` chosen at random, making sure that we don't pick the same row twice. This will guarantee that all the rows of `X_norm` are chosen and randomly distributed among the three new sets.\n", - "\n", - "You will start by creating a rank 1 ndarray that contains a random permutation of the row indices of `X_norm`. You can do this by using the `np.random.permutation()` function. The `np.random.permutation(N)` function creates a random permutation of integers from 0 to `N - 1`. Let's see an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0, 1, 3, 4, 2])" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We create a random permutation of integers 0 to 4\n", - "np.random.permutation(5)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# To Do\n", - "\n", - "In the space below create a rank 1 ndarray that contains a random permutation of the row indices of `X_norm`. You can do this in one line of code by extracting the number of rows of `X_norm` using the `shape` attribute and then passing it to the `np.random.permutation()` function. Remember the `shape` attribute returns a tuple with two numbers in the form `(rows,columns)`." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1000,)\n" - ] - } - ], - "source": [ - "# Create a rank 1 ndarray that contains a random permutation of the row indices of `X_norm`\n", - "row_indices = np.random.permutation(X_norm.shape[0])\n", - "print(row_indices.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now you can create the three datasets using the `row_indices` ndarray to select the rows that will go into each dataset. Rememeber that the Training Set contains 60% of the data, the Cross Validation Set contains 20% of the data, and the Test Set contains 20% of the data. Each set requires just one line of code to create. Fill in the code below" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "# Make any necessary calculations.\n", - "# You can save your calculations into variables to use later.\n", - "\n", - "\n", - "# Create a Training Set\n", - "X_train = X[row_indices[:600], :]\n", - "\n", - "# Create a Cross Validation Set\n", - "X_crossVal = X[row_indices[600:800], :]\n", - "\n", - "# Create a Test Set\n", - "X_test = X[row_indices[800:], :]\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you performed the above calculations correctly, then `X_tain` should have 600 rows and 20 columns, `X_crossVal` should have 200 rows and 20 columns, and `X_test` should have 200 rows and 20 columns. You can verify this by filling the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(600, 20)\n", - "(200, 20)\n", - "(200, 20)\n" - ] - } - ], - "source": [ - "# Print the shape of X_train\n", - "print(X_train.shape)\n", - "\n", - "# Print the shape of X_crossVal\n", - "print(X_crossVal.shape)\n", - "\n", - "# Print the shape of X_test\n", - "print(X_test.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [default]", - "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.6.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} +{"cells":[{"cell_type":"markdown","metadata":{},"source":["# Mean Normalization\n","\n","In machine learning we use large amounts of data to train our models. Some machine learning algorithms may require that the data is *normalized* in order to work correctly. The idea of normalization, also known as *feature scaling*, is to ensure that all the data is on a similar scale, *i.e.* that all the data takes on a similar range of values. For example, we might have a dataset that has values between 0 and 5,000. By normalizing the data we can make the range of values be between 0 and 1.\n","\n","In this lab, you will be performing a different kind of feature scaling known as *mean normalization*. Mean normalization will scale the data, but instead of making the values be between 0 and 1, it will distribute the values evenly in some small interval around zero. For example, if we have a dataset that has values between 0 and 5,000, after mean normalization the range of values will be distributed in some small range around 0, for example between -3 to 3. Because the range of values are distributed evenly around zero, this guarantees that the average (mean) of all elements will be zero. Therefore, when you perform *mean normalization* your data will not only be scaled but it will also have an average of zero. \n","\n","# To Do:\n","\n","You will start by importing NumPy and creating a rank 2 ndarray of random integers between 0 and 5,000 (inclusive) with 1000 rows and 20 columns. This array will simulate a dataset with a wide range of values. Fill in the code below"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# import NumPy into Python\n","import numpy as np\n","\n","# Create a 1000 x 20 ndarray with random integers in the half-open interval [0, 5001).\n","X = np.random.randint(0, 5001, size=(1000,20))\n","\n","# print the shape of X\n","print(X.shape)"]},{"cell_type":"markdown","metadata":{},"source":["Now that you created the array we will mean normalize it. We will perform mean normalization using the following equation:\n","\n","$\\mbox{Norm_Col}_i = \\frac{\\mbox{Col}_i - \\mu_i}{\\sigma_i}$\n","\n","where $\\mbox{Col}_i$ is the $i$th column of $X$, $\\mu_i$ is average of the values in the $i$th column of $X$, and $\\sigma_i$ is the standard deviation of the values in the $i$th column of $X$. In other words, mean normalization is performed by subtracting from each column of $X$ the average of its values, and then by dividing by the standard deviation of its values. In the space below, you will first calculate the average and standard deviation of each column of $X$. "]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Average of the values in each column of X\n","ave_cols = X.mean(axis=0)\n","\n","# Standard Deviation of the values in each column of X\n","std_cols = X.std(axis=0)"]},{"cell_type":"markdown","metadata":{},"source":["If you have done the above calculations correctly, then `ave_cols` and `std_cols`, should both be vectors with shape `(20,)` since $X$ has 20 columns. You can verify this by filling the code below:"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Print the shape of ave_cols\n","print(ave_cols.shape)\n","\n","# Print the shape of std_cols\n","print(std_cols.shape)"]},{"cell_type":"markdown","metadata":{},"source":["You can now take advantage of Broadcasting to calculate the mean normalized version of $X$ in just one line of code using the equation above. Fill in the code below"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Mean normalize X\n","X_norm = (X - ave_cols) / std_cols\n","print(X_norm.shape)"]},{"cell_type":"markdown","metadata":{},"source":["If you have performed the mean normalization correctly, then the average of all the elements in $X_{\\tiny{\\mbox{norm}}}$ should be close to zero, and they should be evenly distributed in some small interval around zero. You can verify this by filing the code below:"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Print the average of all the values of X_norm\n","print(X_norm.mean())\n","\n","# Print the average of the minimum value in each column of X_norm\n","print(X_norm.min(axis=0).mean())\n","\n","# Print the average of the maximum value in each column of X_norm\n"]},{"cell_type":"markdown","metadata":{},"source":["You should note that since $X$ was created using random integers, the above values will vary. \n","\n","# Data Separation\n","\n","After the data has been mean normalized, it is customary in machine learnig to split our dataset into three sets:\n","\n","1. A Training Set\n","2. A Cross Validation Set\n","3. A Test Set\n","\n","The dataset is usually divided such that the Training Set contains 60% of the data, the Cross Validation Set contains 20% of the data, and the Test Set contains 20% of the data. \n","\n","In this part of the lab you will separate `X_norm` into a Training Set, Cross Validation Set, and a Test Set. Each data set will contain rows of `X_norm` chosen at random, making sure that we don't pick the same row twice. This will guarantee that all the rows of `X_norm` are chosen and randomly distributed among the three new sets.\n","\n","You will start by creating a rank 1 ndarray that contains a random permutation of the row indices of `X_norm`. You can do this by using the `np.random.permutation()` function. The `np.random.permutation(N)` function creates a random permutation of integers from 0 to `N - 1`. Let's see an example:"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# We create a random permutation of integers 0 to 4\n","np.random.permutation(5)"]},{"cell_type":"markdown","metadata":{},"source":["# To Do\n","\n","In the space below create a rank 1 ndarray that contains a random permutation of the row indices of `X_norm`. You can do this in one line of code by extracting the number of rows of `X_norm` using the `shape` attribute and then passing it to the `np.random.permutation()` function. Remember the `shape` attribute returns a tuple with two numbers in the form `(rows,columns)`."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Create a rank 1 ndarray that contains a random permutation of the row indices of `X_norm`\n","row_indices = np.random.permutation(X_norm.shape[0])\n","print(row_indices.shape)"]},{"cell_type":"markdown","metadata":{},"source":["Now you can create the three datasets using the `row_indices` ndarray to select the rows that will go into each dataset. Rememeber that the Training Set contains 60% of the data, the Cross Validation Set contains 20% of the data, and the Test Set contains 20% of the data. Each set requires just one line of code to create. Fill in the code below"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Make any necessary calculations.\n","# You can save your calculations into variables to use later.\n","\n","\n","# Create a Training Set\n","X_train = X[row_indices[:600], :]\n","\n","# Create a Cross Validation Set\n","X_crossVal = X[row_indices[600:800], :]\n","\n","# Create a Test Set\n","X_test = X[row_indices[800:], :]\n"]},{"cell_type":"markdown","metadata":{},"source":["If you performed the above calculations correctly, then `X_tain` should have 600 rows and 20 columns, `X_crossVal` should have 200 rows and 20 columns, and `X_test` should have 200 rows and 20 columns. You can verify this by filling the code below:"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Print the shape of X_train\n","print(X_train.shape)\n","\n","# Print the shape of X_crossVal\n","print(X_crossVal.shape)\n","\n","# Print the shape of X_test\n","print(X_test.shape)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]}],"metadata":{"kernelspec":{"display_name":"Python [default]","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.6.3"}},"nbformat":4,"nbformat_minor":2} \ No newline at end of file diff --git a/Pandas/.ipynb_checkpoints/Statistics from Stock Data-checkpoint.ipynb b/Pandas/.ipynb_checkpoints/Statistics from Stock Data-checkpoint.ipynb deleted file mode 100644 index 9250516..0000000 --- a/Pandas/.ipynb_checkpoints/Statistics from Stock Data-checkpoint.ipynb +++ /dev/null @@ -1,1052 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Statistics from Stock Data\n", - "\n", - "In this lab we will load stock data into a Pandas Dataframe and calculate some statistics on it. We will be working with stock data from Google, Apple, and Amazon. All the stock data was downloaded from yahoo finance in CSV format. In your workspace you should have a file named GOOG.csv containing the Google stock data, a file named AAPL.csv containing the Apple stock data, and a file named AMZN.csv containing the Amazon stock data. (You can see the workspace folder by clicking on the Jupyter logo in the upper left corner of the workspace.) All the files contain 7 columns of data:\n", - "\n", - "**Date Open High Low Close Adj_Close Volume**\n", - "\n", - "We will start by reading in any of the above CSV files into a DataFrame and see what the data looks like." - ] - }, - { - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
DateOpenHighLowCloseAdj CloseVolume
02004-08-1949.67689951.69378347.66995249.84580249.84580244994500.0
12004-08-2050.17863554.18756149.92528553.80505053.80505023005800.0
22004-08-2355.01716656.37334454.17266154.34652754.34652718393200.0
32004-08-2455.26058255.43941951.45036352.09616552.09616515361800.0
42004-08-2552.14087353.65105151.60436252.65751352.6575139257400.0
\n", - "
" - ], - "text/plain": [ - " Date Open High Low Close Adj Close \\\n", - "0 2004-08-19 49.676899 51.693783 47.669952 49.845802 49.845802 \n", - "1 2004-08-20 50.178635 54.187561 49.925285 53.805050 53.805050 \n", - "2 2004-08-23 55.017166 56.373344 54.172661 54.346527 54.346527 \n", - "3 2004-08-24 55.260582 55.439419 51.450363 52.096165 52.096165 \n", - "4 2004-08-25 52.140873 53.651051 51.604362 52.657513 52.657513 \n", - "\n", - " Volume \n", - "0 44994500.0 \n", - "1 23005800.0 \n", - "2 18393200.0 \n", - "3 15361800.0 \n", - "4 9257400.0 " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We import pandas into Python\n", - "import pandas as pd\n", - "\n", - "# We read in a stock data data file into a data frame and see what it looks like\n", - "df = pd.read_csv('./GOOG.csv')\n", - "\n", - "# We display the first 5 rows of the DataFrame\n", - "df.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We clearly see that the Dataframe is has automatically labeled the row indices using integers and has labeled the columns of the DataFrame using the names of the columns in the CSV files.\n", - "\n", - "# To Do\n", - "\n", - "You will now load the stock data from Google, Apple, and Amazon into separte DataFrames. However, for each stock data you will only be interested in loading the `Date` and `Adj Close` columns into the Dataframe. In addtion, you want to use the `Date` column as your row index. Finally, you want the DataFrame to recognize the dates as actual dates (year/month/day) and not as strings. For each stock, you can accomplish all theses things in just one line of code by using the appropiate keywords in the `pd.read_csv()` function. Here are a few hints:\n", - "\n", - "* Use the `index_col` keyword to indicate which column you want to use as an index. For example `index_col = ['Open']`\n", - "\n", - "* Set the `parse_dates` keyword equal to `True` to convert the Dates into real dates of the form year/month/day\n", - "\n", - "* Use the `usecols` keyword to select which columns you want to load into the DataFrame. For example `usecols = ['Open', 'High']`\n", - "\n", - "Fill in the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# We load the Google stock data into a DataFrame\n", - "google_stock = pd.read_csv('./GOOG.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])\n", - "\n", - "# We load the Apple stock data into a DataFrame\n", - "apple_stock = pd.read_csv('./AAPL.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])\n", - "\n", - "# We load the Amazon stock data into a DataFrame\n", - "amazon_stock = pd.read_csv('./AMZN.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can check that you have loaded the data correctly by displaying the head of the DataFrames." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "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", - "
Adj Close
Date
2004-08-1949.845802
2004-08-2053.805050
2004-08-2354.346527
2004-08-2452.096165
2004-08-2552.657513
\n", - "
" - ], - "text/plain": [ - " Adj Close\n", - "Date \n", - "2004-08-19 49.845802\n", - "2004-08-20 53.805050\n", - "2004-08-23 54.346527\n", - "2004-08-24 52.096165\n", - "2004-08-25 52.657513" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We display the google_stock DataFrame\n", - "google_stock.head()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "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", - "
Adj Close
Date
2000-01-0389.3750
2000-01-0481.9375
2000-01-0569.7500
\n", - "
" - ], - "text/plain": [ - " Adj Close\n", - "Date \n", - "2000-01-03 89.3750\n", - "2000-01-04 81.9375\n", - "2000-01-05 69.7500" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "amazon_stock.head(3)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "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", - "
Adj Close
Date
2000-01-033.596616
2000-01-043.293384
2000-01-053.341579
\n", - "
" - ], - "text/plain": [ - " Adj Close\n", - "Date \n", - "2000-01-03 3.596616\n", - "2000-01-04 3.293384\n", - "2000-01-05 3.341579" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "apple_stock.head(3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You will now join the three DataFrames above to create a single new DataFrame that contains all the `Adj Close` for all the stocks. Let's start by creating an empty DataFrame that has as row indices calendar days between `2000-01-01` and `2016-12-31`. We will use the `pd.date_range()` function to create the calendar dates first and then we will create a DataFrame that uses those dates as row indices:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# We create calendar dates between '2000-01-01' and '2016-12-31'\n", - "dates = pd.date_range('2000-01-01', '2016-12-31')\n", - "\n", - "# We create and empty DataFrame that uses the above dates as indices\n", - "all_stocks = pd.DataFrame(index = dates)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# To Do\n", - "\n", - "You will now join the the individual DataFrames, `google_stock`, `apple_stock`, and `amazon_stock`, to the `all_stocks` DataFrame. However, before you do this, it is necessary that you change the name of the columns in each of the three dataframes. This is because the column labels in the `all_stocks` dataframe must be unique. Since all the columns in the individual dataframes have the same name, `Adj Close`, we must change them to the stock name before joining them. In the space below change the column label `Adj Close` of each individual dataframe to the name of the corresponding stock. You can do this by using the `pd.DataFrame.rename()` function. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# Change the Adj Close column label to Google\n", - "google_stock.rename(columns={'Adj Close': 'google_stock'}, inplace=True)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# Change the Adj Close column label to Amazon\n", - "amazon_stock.rename(columns={'Adj Close': 'amazon_stock'}, inplace=True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "\n", - "# Change the Adj Close column label to Apple\n", - "apple_stock.rename(columns={'Adj Close': 'apple_stock'}, inplace=True)" - ] - }, - { - "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", - "
google_stock
Date
2004-08-1949.845802
2004-08-2053.805050
2004-08-2354.346527
2004-08-2452.096165
2004-08-2552.657513
\n", - "
" - ], - "text/plain": [ - " google_stock\n", - "Date \n", - "2004-08-19 49.845802\n", - "2004-08-20 53.805050\n", - "2004-08-23 54.346527\n", - "2004-08-24 52.096165\n", - "2004-08-25 52.657513" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "google_stock.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can check that the column labels have been changed correctly by displaying the datadrames" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "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", - "
amazon_stock
Date
2000-01-0389.3750
2000-01-0481.9375
2000-01-0569.7500
2000-01-0665.5625
2000-01-0769.5625
\n", - "
" - ], - "text/plain": [ - " amazon_stock\n", - "Date \n", - "2000-01-03 89.3750\n", - "2000-01-04 81.9375\n", - "2000-01-05 69.7500\n", - "2000-01-06 65.5625\n", - "2000-01-07 69.5625" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We display the google_stock DataFrame\n", - "amazon_stock.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that we have unique column labels, we can join the individual DataFrames to the `all_stocks` DataFrame. For this we will use the `dataframe.join()` function. The function `dataframe1.join(dataframe2)` joins `dataframe1` with `dataframe2`. We will join each dataframe one by one to the `all_stocks` dataframe. Fill in the code below to join the dataframes, the first join has been made for you:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "# We join the Google stock to all_stocks\n", - "all_stocks = all_stocks.join(google_stock)\n", - "\n", - "# We join the Apple stock to all_stocks\n", - "all_stocks = all_stocks.join(apple_stock)\n", - "\n", - "# We join the Amazon stock to all_stocks\n", - "all_stocks = all_stocks.join(amazon_stock)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can check that the dataframes have been joined correctly by displaying the `all_stocks` dataframe" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "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", - "
google_stockapple_stockamazon_stock
2000-01-01 00:00:00NaNNaNNaN
2000-01-02 00:00:00NaNNaNNaN
2000-01-03 00:00:00NaNNaNNaN
2000-01-04 00:00:00NaNNaNNaN
2000-01-05 00:00:00NaNNaNNaN
\n", - "
" - ], - "text/plain": [ - " google_stock apple_stock amazon_stock\n", - "2000-01-01 00:00:00 NaN NaN NaN\n", - "2000-01-02 00:00:00 NaN NaN NaN\n", - "2000-01-03 00:00:00 NaN NaN NaN\n", - "2000-01-04 00:00:00 NaN NaN NaN\n", - "2000-01-05 00:00:00 NaN NaN NaN" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We display the google_stock DataFrame\n", - "all_stocks.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# To Do\n", - "\n", - "Before we proceed to get some statistics on the stock data, let's first check that we don't have any *NaN* values. In the space below check if there are any *NaN* values in the `all_stocks` dataframe. If there are any, remove any rows that have *NaN* values:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
google_stockapple_stockamazon_stock
\n", - "
" - ], - "text/plain": [ - "Empty DataFrame\n", - "Columns: [google_stock, apple_stock, amazon_stock]\n", - "Index: []" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Check if there are any NaN values in the all_stocks dataframe\n", - "all_stocks.isnull()\n", - "\n", - "# Remove any rows that contain NaN values\n", - "all_stocks.dropna(axis=0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that you have eliminated any *NaN* values we can now calculate some basic statistics on the stock prices. Fill in the code below" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mean:\n", - " google_stock NaN\n", - "apple_stock NaN\n", - "amazon_stock NaN\n", - "dtype: float64\n", - "\n", - "median:\n", - " google_stock NaN\n", - "apple_stock NaN\n", - "amazon_stock NaN\n", - "dtype: float64\n", - "\n", - "std:\n", - " google_stock NaN\n", - "apple_stock NaN\n", - "amazon_stock NaN\n", - "dtype: float64\n", - "\n", - "corr:\n", - " google_stock apple_stock amazon_stock\n", - "google_stock NaN NaN NaN\n", - "apple_stock NaN NaN NaN\n", - "amazon_stock NaN NaN NaN\n" - ] - } - ], - "source": [ - "# Print the average stock price for each stock\n", - "print('mean:\\n ',all_stocks.mean(axis=0))\n", - "print()\n", - "\n", - "# Print the median stock price for each stock\n", - "print('median:\\n ', all_stocks.median())\n", - "print()\n", - "# Print the standard deviation of the stock price for each stock \n", - "print('std:\\n ', all_stocks.std())\n", - "print()\n", - "# Print the correlation between stocks\n", - "print('corr:\\n', all_stocks.corr())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will now look at how we can compute some rolling statistics, also known as moving statistics. We can calculate for example the rolling mean (moving average) of the Google stock price by using the Pandas `dataframe.rolling().mean()` method. The `dataframe.rolling(N).mean()` calculates the rolling mean over an `N`-day window. In other words, we can take a look at the average stock price every `N` days using the above method. Fill in the code below to calculate the average stock price every 150 days for Google stock" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2000-01-01 NaN\n", - "2000-01-02 NaN\n", - "2000-01-03 NaN\n", - "2000-01-04 NaN\n", - "2000-01-05 NaN\n", - "2000-01-06 NaN\n", - "2000-01-07 NaN\n", - "2000-01-08 NaN\n", - "2000-01-09 NaN\n", - "2000-01-10 NaN\n", - "2000-01-11 NaN\n", - "2000-01-12 NaN\n", - "2000-01-13 NaN\n", - "2000-01-14 NaN\n", - "2000-01-15 NaN\n", - "2000-01-16 NaN\n", - "2000-01-17 NaN\n", - "2000-01-18 NaN\n", - "2000-01-19 NaN\n", - "2000-01-20 NaN\n", - "2000-01-21 NaN\n", - "2000-01-22 NaN\n", - "2000-01-23 NaN\n", - "2000-01-24 NaN\n", - "2000-01-25 NaN\n", - "2000-01-26 NaN\n", - "2000-01-27 NaN\n", - "2000-01-28 NaN\n", - "2000-01-29 NaN\n", - "2000-01-30 NaN\n", - " ..\n", - "2016-12-02 NaN\n", - "2016-12-03 NaN\n", - "2016-12-04 NaN\n", - "2016-12-05 NaN\n", - "2016-12-06 NaN\n", - "2016-12-07 NaN\n", - "2016-12-08 NaN\n", - "2016-12-09 NaN\n", - "2016-12-10 NaN\n", - "2016-12-11 NaN\n", - "2016-12-12 NaN\n", - "2016-12-13 NaN\n", - "2016-12-14 NaN\n", - "2016-12-15 NaN\n", - "2016-12-16 NaN\n", - "2016-12-17 NaN\n", - "2016-12-18 NaN\n", - "2016-12-19 NaN\n", - "2016-12-20 NaN\n", - "2016-12-21 NaN\n", - "2016-12-22 NaN\n", - "2016-12-23 NaN\n", - "2016-12-24 NaN\n", - "2016-12-25 NaN\n", - "2016-12-26 NaN\n", - "2016-12-27 NaN\n", - "2016-12-28 NaN\n", - "2016-12-29 NaN\n", - "2016-12-30 NaN\n", - "2016-12-31 NaN\n", - "Name: amazon_stock, Length: 6210, dtype: float64\n" - ] - } - ], - "source": [ - "# We compute the rolling mean using a 150-Day window for Google stock\n", - "rollingMean = all_stocks['amazon_stock'].rolling(3).mean()\n", - "print(rollingMean)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can also visualize the rolling mean by plotting the data in our dataframe. In the following lessons you will learn how to use **Matplotlib** to visualize data. For now I will just import matplotlib and plot the Google stock data on top of the rolling mean. You can play around by changing the rolling mean window and see how the plot changes. " - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "ordinal must be >= 1", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 330\u001b[0m \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 331\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 332\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mprinter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 333\u001b[0m \u001b[0;31m# Finally look for special method names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 334\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_real_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_method\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36m\u001b[0;34m(fig)\u001b[0m\n\u001b[1;32m 235\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'png'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 237\u001b[0;31m \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'png'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 238\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'retina'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m'png2x'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 239\u001b[0m \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mretina_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(fig, fmt, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[0mbytes_io\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBytesIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 121\u001b[0;31m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_io\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 122\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbytes_io\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'svg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, **kwargs)\u001b[0m\n\u001b[1;32m 2206\u001b[0m \u001b[0morientation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morientation\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2207\u001b[0m \u001b[0mdryrun\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2208\u001b[0;31m **kwargs)\n\u001b[0m\u001b[1;32m 2209\u001b[0m \u001b[0mrenderer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cachedRenderer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2210\u001b[0m \u001b[0mbbox_inches\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_tightbbox\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/backends/backend_agg.py\u001b[0m in \u001b[0;36mprint_png\u001b[0;34m(self, filename_or_obj, *args, **kwargs)\u001b[0m\n\u001b[1;32m 505\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 506\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mprint_png\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfilename_or_obj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 507\u001b[0;31m \u001b[0mFigureCanvasAgg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 508\u001b[0m \u001b[0mrenderer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_renderer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 509\u001b[0m \u001b[0moriginal_dpi\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdpi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/backends/backend_agg.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 428\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtoolbar\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 429\u001b[0m \u001b[0mtoolbar\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_cursor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcursors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mWAIT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 430\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 431\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 432\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtoolbar\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 56\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 1293\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1294\u001b[0m mimage._draw_list_compositing_images(\n\u001b[0;32m-> 1295\u001b[0;31m renderer, self, artists, self.suppressComposite)\n\u001b[0m\u001b[1;32m 1296\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1297\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'figure'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 139\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 140\u001b[0m \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 56\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer, inframe)\u001b[0m\n\u001b[1;32m 2397\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_rasterizing\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2398\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2399\u001b[0;31m \u001b[0mmimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_draw_list_compositing_images\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2400\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2401\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'axes'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 138\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 139\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 140\u001b[0m \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 56\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1131\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1132\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1133\u001b[0;31m \u001b[0mticks_to_draw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1134\u001b[0m ticklabelBoxes, ticklabelBoxes2 = self._get_tick_bboxes(ticks_to_draw,\n\u001b[1;32m 1135\u001b[0m renderer)\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_update_ticks\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 972\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 973\u001b[0m \u001b[0minterval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_view_interval\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 974\u001b[0;31m \u001b[0mtick_tups\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miter_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 975\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_smart_bounds\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mtick_tups\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 976\u001b[0m \u001b[0;31m# handle inverted limits\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36miter_ticks\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 915\u001b[0m \u001b[0mIterate\u001b[0m \u001b[0mthrough\u001b[0m \u001b[0mall\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mmajor\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mminor\u001b[0m \u001b[0mticks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 916\u001b[0m \"\"\"\n\u001b[0;32m--> 917\u001b[0;31m \u001b[0mmajorLocs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlocator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 918\u001b[0m \u001b[0mmajorTicks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_major_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmajorLocs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 919\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_locs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmajorLocs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/dates.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1052\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1053\u001b[0m \u001b[0;34m'Return the locations of the ticks'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1054\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrefresh\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1055\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_locator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1056\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/dates.py\u001b[0m in \u001b[0;36mrefresh\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1072\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mrefresh\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1073\u001b[0m \u001b[0;34m'Refresh internal information based on current limits.'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1074\u001b[0;31m \u001b[0mdmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdmax\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mviewlim_to_dt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1075\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_locator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_locator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdmax\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1076\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/dates.py\u001b[0m in \u001b[0;36mviewlim_to_dt\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 830\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 831\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 832\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mnum2date\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum2date\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvmax\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 833\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 834\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_get_unit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/dates.py\u001b[0m in \u001b[0;36mnum2date\u001b[0;34m(x, tz)\u001b[0m\n\u001b[1;32m 439\u001b[0m \u001b[0mtz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_get_rc_timezone\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 440\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miterable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 441\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_from_ordinalf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 442\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 443\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/envs/dl/lib/python3.6/site-packages/matplotlib/dates.py\u001b[0m in \u001b[0;36m_from_ordinalf\u001b[0;34m(x, tz)\u001b[0m\n\u001b[1;32m 254\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 255\u001b[0m \u001b[0mix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 256\u001b[0;31m \u001b[0mdt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdatetime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfromordinal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreplace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtzinfo\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mUTC\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 257\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 258\u001b[0m \u001b[0mremainder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: ordinal must be >= 1" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# this allows plots to be rendered in the notebook\n", - "%matplotlib inline \n", - "\n", - "# We import matplotlib into Python\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "# We plot the Google stock data\n", - "plt.plot(all_stocks['amazon_stock'])\n", - "\n", - "# We plot the rolling mean ontop of our Google stock data\n", - "plt.plot(rollingMean)\n", - "plt.legend(['Amazon Stock Price', 'Rolling Mean'])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [default]", - "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.6.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Pandas/.ipynb_checkpoints/Statistics-from-Stock-Data-checkpoint.ipynb b/Pandas/.ipynb_checkpoints/Statistics-from-Stock-Data-checkpoint.ipynb deleted file mode 100644 index e537629..0000000 --- a/Pandas/.ipynb_checkpoints/Statistics-from-Stock-Data-checkpoint.ipynb +++ /dev/null @@ -1,1443 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Statistics from Stock Data\n", - "\n", - "In this lab we will load stock data into a Pandas Dataframe and calculate some statistics on it. We will be working with stock data from Google, Apple, and Amazon. All the stock data was downloaded from yahoo finance in CSV format. In your workspace you should have a file named GOOG.csv containing the Google stock data, a file named AAPL.csv containing the Apple stock data, and a file named AMZN.csv containing the Amazon stock data. (You can see the workspace folder by clicking on the Jupyter logo in the upper left corner of the workspace.) All the files contain 7 columns of data:\n", - "\n", - "**Date Open High Low Close Adj_Close Volume**\n", - "\n", - "We will start by reading in any of the above CSV files into a DataFrame and see what the data looks like." - ] - }, - { - "cell_type": "code", - "execution_count": 140, - "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", - "
DateOpenHighLowCloseAdj CloseVolume
02004-08-1949.67689951.69378347.66995249.84580249.84580244994500
12004-08-2050.17863554.18756149.92528553.80505053.80505023005800
22004-08-2355.01716656.37334454.17266154.34652754.34652718393200
32004-08-2455.26058255.43941951.45036352.09616552.09616515361800
42004-08-2552.14087353.65105151.60436252.65751352.6575139257400
\n", - "
" - ], - "text/plain": [ - " Date Open High Low Close Adj Close Volume\n", - "0 2004-08-19 49.676899 51.693783 47.669952 49.845802 49.845802 44994500\n", - "1 2004-08-20 50.178635 54.187561 49.925285 53.805050 53.805050 23005800\n", - "2 2004-08-23 55.017166 56.373344 54.172661 54.346527 54.346527 18393200\n", - "3 2004-08-24 55.260582 55.439419 51.450363 52.096165 52.096165 15361800\n", - "4 2004-08-25 52.140873 53.651051 51.604362 52.657513 52.657513 9257400" - ] - }, - "execution_count": 140, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We import pandas into Python\n", - "import pandas as pd\n", - "\n", - "# We read in a stock data data file into a data frame and see what it looks like\n", - "df = pd.read_csv('./GOOG.csv')\n", - "\n", - "# We display the first 5 rows of the DataFrame\n", - "df.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We clearly see that the Dataframe is has automatically labeled the row indices using integers and has labeled the columns of the DataFrame using the names of the columns in the CSV files.\n", - "\n", - "# To Do\n", - "\n", - "You will now load the stock data from Google, Apple, and Amazon into separte DataFrames. However, for each stock data you will only be interested in loading the `Date` and `Adj Close` columns into the Dataframe. In addtion, you want to use the `Date` column as your row index. Finally, you want the DataFrame to recognize the dates as actual dates (year/month/day) and not as strings. For each stock, you can accomplish all theses things in just one line of code by using the appropiate keywords in the `pd.read_csv()` function. Here are a few hints:\n", - "\n", - "* Use the `index_col` keyword to indicate which column you want to use as an index. For example `index_col = ['Open']`\n", - "\n", - "* Set the `parse_dates` keyword equal to `True` to convert the Dates into real dates of the form year/month/day\n", - "\n", - "* Use the `usecols` keyword to select which columns you want to load into the DataFrame. For example `usecols = ['Open', 'High']`\n", - "\n", - "Fill in the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 141, - "metadata": {}, - "outputs": [], - "source": [ - "# We load the Google stock data into a DataFrame\n", - "google_stock = pd.read_csv('./GOOG.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])\n", - "\n", - "# We load the Apple stock data into a DataFrame\n", - "apple_stock = pd.read_csv('./AAPL.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])\n", - "\n", - "# We load the Amazon stock data into a DataFrame\n", - "amazon_stock = pd.read_csv('./AMZN.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can check that you have loaded the data correctly by displaying the head of the DataFrames." - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "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", - "
Adj Close
Date
2004-08-1949.845802
2004-08-2053.805050
2004-08-2354.346527
2004-08-2452.096165
2004-08-2552.657513
\n", - "
" - ], - "text/plain": [ - " Adj Close\n", - "Date \n", - "2004-08-19 49.845802\n", - "2004-08-20 53.805050\n", - "2004-08-23 54.346527\n", - "2004-08-24 52.096165\n", - "2004-08-25 52.657513" - ] - }, - "execution_count": 142, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We display the google_stock DataFrame\n", - "google_stock.head()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 143, - "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", - "
Adj Close
Date
2000-01-0389.3750
2000-01-0481.9375
2000-01-0569.7500
\n", - "
" - ], - "text/plain": [ - " Adj Close\n", - "Date \n", - "2000-01-03 89.3750\n", - "2000-01-04 81.9375\n", - "2000-01-05 69.7500" - ] - }, - "execution_count": 143, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "amazon_stock.head(3)" - ] - }, - { - "cell_type": "code", - "execution_count": 144, - "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", - "
Adj Close
Date
2000-01-033.596616
2000-01-043.293384
2000-01-053.341579
\n", - "
" - ], - "text/plain": [ - " Adj Close\n", - "Date \n", - "2000-01-03 3.596616\n", - "2000-01-04 3.293384\n", - "2000-01-05 3.341579" - ] - }, - "execution_count": 144, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "apple_stock.head(3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You will now join the three DataFrames above to create a single new DataFrame that contains all the `Adj Close` for all the stocks. Let's start by creating an empty DataFrame that has as row indices calendar days between `2000-01-01` and `2016-12-31`. We will use the `pd.date_range()` function to create the calendar dates first and then we will create a DataFrame that uses those dates as row indices:" - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "metadata": {}, - "outputs": [], - "source": [ - "# We create calendar dates between '2000-01-01' and '2016-12-31'\n", - "dates = pd.date_range('2000-01-01', '2016-12-31')\n", - "\n", - "# We create and empty DataFrame that uses the above dates as indices\n", - "all_stocks = pd.DataFrame(index = dates)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# To Do\n", - "\n", - "You will now join the the individual DataFrames, `google_stock`, `apple_stock`, and `amazon_stock`, to the `all_stocks` DataFrame. However, before you do this, it is necessary that you change the name of the columns in each of the three dataframes. This is because the column labels in the `all_stocks` dataframe must be unique. Since all the columns in the individual dataframes have the same name, `Adj Close`, we must change them to the stock name before joining them. In the space below change the column label `Adj Close` of each individual dataframe to the name of the corresponding stock. You can do this by using the `pd.DataFrame.rename()` function. " - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "metadata": {}, - "outputs": [], - "source": [ - "# Change the Adj Close column label to Google\n", - "google_stock.rename(columns={'Adj Close': 'google_stock'}, inplace=True)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 148, - "metadata": {}, - "outputs": [], - "source": [ - "# Change the Adj Close column label to Amazon\n", - "amazon_stock.rename(columns={'Adj Close': 'amazon_stock'}, inplace=True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 149, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "\n", - "# Change the Adj Close column label to Apple\n", - "apple_stock.rename(columns={'Adj Close': 'apple_stock'}, inplace=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 150, - "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", - "
google_stock
Date
2004-08-1949.845802
2004-08-2053.805050
2004-08-2354.346527
2004-08-2452.096165
2004-08-2552.657513
\n", - "
" - ], - "text/plain": [ - " google_stock\n", - "Date \n", - "2004-08-19 49.845802\n", - "2004-08-20 53.805050\n", - "2004-08-23 54.346527\n", - "2004-08-24 52.096165\n", - "2004-08-25 52.657513" - ] - }, - "execution_count": 150, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "google_stock.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can check that the column labels have been changed correctly by displaying the datadrames" - ] - }, - { - "cell_type": "code", - "execution_count": 151, - "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", - "
amazon_stock
Date
2000-01-0389.3750
2000-01-0481.9375
2000-01-0569.7500
2000-01-0665.5625
2000-01-0769.5625
\n", - "
" - ], - "text/plain": [ - " amazon_stock\n", - "Date \n", - "2000-01-03 89.3750\n", - "2000-01-04 81.9375\n", - "2000-01-05 69.7500\n", - "2000-01-06 65.5625\n", - "2000-01-07 69.5625" - ] - }, - "execution_count": 151, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We display the google_stock DataFrame\n", - "amazon_stock.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that we have unique column labels, we can join the individual DataFrames to the `all_stocks` DataFrame. For this we will use the `dataframe.join()` function. The function `dataframe1.join(dataframe2)` joins `dataframe1` with `dataframe2`. We will join each dataframe one by one to the `all_stocks` dataframe. Fill in the code below to join the dataframes, the first join has been made for you:" - ] - }, - { - "cell_type": "code", - "execution_count": 152, - "metadata": {}, - "outputs": [], - "source": [ - "# We join the Google stock to all_stocks\n", - "all_stocks = all_stocks.join(google_stock)\n", - "\n", - "# We join the Apple stock to all_stocks\n", - "all_stocks = all_stocks.join(apple_stock)\n", - "\n", - "# We join the Amazon stock to all_stocks\n", - "all_stocks = all_stocks.join(amazon_stock)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can check that the dataframes have been joined correctly by displaying the `all_stocks` dataframe" - ] - }, - { - "cell_type": "code", - "execution_count": 153, - "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", - "
google_stockapple_stockamazon_stock
2000-01-01NaNNaNNaN
2000-01-02NaNNaNNaN
2000-01-03NaN3.59661689.3750
2000-01-04NaN3.29338481.9375
2000-01-05NaN3.34157969.7500
\n", - "
" - ], - "text/plain": [ - " google_stock apple_stock amazon_stock\n", - "2000-01-01 NaN NaN NaN\n", - "2000-01-02 NaN NaN NaN\n", - "2000-01-03 NaN 3.596616 89.3750\n", - "2000-01-04 NaN 3.293384 81.9375\n", - "2000-01-05 NaN 3.341579 69.7500" - ] - }, - "execution_count": 153, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We display the google_stock DataFrame\n", - "all_stocks.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# To Do\n", - "\n", - "Before we proceed to get some statistics on the stock data, let's first check that we don't have any *NaN* values. In the space below check if there are any *NaN* values in the `all_stocks` dataframe. If there are any, remove any rows that have *NaN* values:" - ] - }, - { - "cell_type": "code", - "execution_count": 154, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
google_stockapple_stockamazon_stock
2004-08-1949.8458021.97346038.630001
2004-08-2053.8050501.97924439.509998
2004-08-2354.3465271.99723639.450001
2004-08-2452.0961652.05314439.049999
2004-08-2552.6575132.12383140.299999
2004-08-2653.6063422.22729140.189999
2004-08-2752.7320292.20737139.900002
2004-08-3050.6754042.19259038.310001
2004-08-3150.8542402.21636738.139999
2004-09-0149.8010902.30440538.240002
2004-09-0250.4270212.29155239.180000
2004-09-0349.6818662.26392038.740002
2004-09-0750.4617962.29797938.509998
2004-09-0850.8194692.33589338.009998
2004-09-0950.8244362.29412238.070000
2004-09-1052.3246772.30504738.570000
2004-09-1353.4026682.28705440.009998
2004-09-1455.3847772.28062842.669998
2004-09-1555.6381262.26199342.209999
2004-09-1656.6167642.33589342.570000
2004-09-1758.3653912.38665942.959999
2004-09-2059.2943462.42328743.270000
2004-09-2158.5392572.44256643.290001
2004-09-2258.8075142.37252141.380001
2004-09-2360.0196302.39501341.830002
2004-09-2459.5278282.39629840.939999
2004-09-2758.7479022.41172139.930000
2004-09-2863.0201152.44449439.430000
2004-09-2965.1164782.48562140.840000
2004-09-3064.3812642.49011940.860001
............
2016-11-17771.229980108.598877756.400024
2016-11-18760.539978108.707527760.159973
2016-11-21769.200012110.357010780.000000
2016-11-22768.270020110.426147785.330017
2016-11-23760.989990109.863159780.119995
2016-11-25761.679993110.416275780.369995
2016-11-28768.239990110.198975766.770020
2016-11-29770.840027110.090332762.520020
2016-11-30758.039978109.161880750.570007
2016-12-01747.919983108.144531743.650024
2016-12-02750.500000108.549500740.340027
2016-12-05762.520020107.769203759.359985
2016-12-06759.109985108.598877764.719971
2016-12-07771.190002109.665604770.419983
2016-12-08776.419983110.742218767.330017
2016-12-09789.289978112.549728768.659973
2016-12-12789.270020111.907722760.119995
2016-12-13796.099976113.774490774.340027
2016-12-14797.070007113.774490768.820007
2016-12-15797.849976114.396751761.000000
2016-12-16790.799988114.544907757.770020
2016-12-19794.200012115.206673766.000000
2016-12-20796.419983115.512863771.219971
2016-12-21794.559998115.621513770.599976
2016-12-22791.260010114.860977766.340027
2016-12-23789.909973115.088142760.590027
2016-12-27791.549988115.819054771.400024
2016-12-28785.049988115.325203772.130005
2016-12-29782.789978115.295570765.150024
2016-12-30771.820007114.396751749.869995
\n", - "

3115 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " google_stock apple_stock amazon_stock\n", - "2004-08-19 49.845802 1.973460 38.630001\n", - "2004-08-20 53.805050 1.979244 39.509998\n", - "2004-08-23 54.346527 1.997236 39.450001\n", - "2004-08-24 52.096165 2.053144 39.049999\n", - "2004-08-25 52.657513 2.123831 40.299999\n", - "2004-08-26 53.606342 2.227291 40.189999\n", - "2004-08-27 52.732029 2.207371 39.900002\n", - "2004-08-30 50.675404 2.192590 38.310001\n", - "2004-08-31 50.854240 2.216367 38.139999\n", - "2004-09-01 49.801090 2.304405 38.240002\n", - "2004-09-02 50.427021 2.291552 39.180000\n", - "2004-09-03 49.681866 2.263920 38.740002\n", - "2004-09-07 50.461796 2.297979 38.509998\n", - "2004-09-08 50.819469 2.335893 38.009998\n", - "2004-09-09 50.824436 2.294122 38.070000\n", - "2004-09-10 52.324677 2.305047 38.570000\n", - "2004-09-13 53.402668 2.287054 40.009998\n", - "2004-09-14 55.384777 2.280628 42.669998\n", - "2004-09-15 55.638126 2.261993 42.209999\n", - "2004-09-16 56.616764 2.335893 42.570000\n", - "2004-09-17 58.365391 2.386659 42.959999\n", - "2004-09-20 59.294346 2.423287 43.270000\n", - "2004-09-21 58.539257 2.442566 43.290001\n", - "2004-09-22 58.807514 2.372521 41.380001\n", - "2004-09-23 60.019630 2.395013 41.830002\n", - "2004-09-24 59.527828 2.396298 40.939999\n", - "2004-09-27 58.747902 2.411721 39.930000\n", - "2004-09-28 63.020115 2.444494 39.430000\n", - "2004-09-29 65.116478 2.485621 40.840000\n", - "2004-09-30 64.381264 2.490119 40.860001\n", - "... ... ... ...\n", - "2016-11-17 771.229980 108.598877 756.400024\n", - "2016-11-18 760.539978 108.707527 760.159973\n", - "2016-11-21 769.200012 110.357010 780.000000\n", - "2016-11-22 768.270020 110.426147 785.330017\n", - "2016-11-23 760.989990 109.863159 780.119995\n", - "2016-11-25 761.679993 110.416275 780.369995\n", - "2016-11-28 768.239990 110.198975 766.770020\n", - "2016-11-29 770.840027 110.090332 762.520020\n", - "2016-11-30 758.039978 109.161880 750.570007\n", - "2016-12-01 747.919983 108.144531 743.650024\n", - "2016-12-02 750.500000 108.549500 740.340027\n", - "2016-12-05 762.520020 107.769203 759.359985\n", - "2016-12-06 759.109985 108.598877 764.719971\n", - "2016-12-07 771.190002 109.665604 770.419983\n", - "2016-12-08 776.419983 110.742218 767.330017\n", - "2016-12-09 789.289978 112.549728 768.659973\n", - "2016-12-12 789.270020 111.907722 760.119995\n", - "2016-12-13 796.099976 113.774490 774.340027\n", - "2016-12-14 797.070007 113.774490 768.820007\n", - "2016-12-15 797.849976 114.396751 761.000000\n", - "2016-12-16 790.799988 114.544907 757.770020\n", - "2016-12-19 794.200012 115.206673 766.000000\n", - "2016-12-20 796.419983 115.512863 771.219971\n", - "2016-12-21 794.559998 115.621513 770.599976\n", - "2016-12-22 791.260010 114.860977 766.340027\n", - "2016-12-23 789.909973 115.088142 760.590027\n", - "2016-12-27 791.549988 115.819054 771.400024\n", - "2016-12-28 785.049988 115.325203 772.130005\n", - "2016-12-29 782.789978 115.295570 765.150024\n", - "2016-12-30 771.820007 114.396751 749.869995\n", - "\n", - "[3115 rows x 3 columns]" - ] - }, - "execution_count": 154, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Check if there are any NaN values in the all_stocks dataframe\n", - "all_stocks.isnull()\n", - "\n", - "# Remove any rows that contain NaN values\n", - "all_stocks.dropna(axis=0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that you have eliminated any *NaN* values we can now calculate some basic statistics on the stock prices. Fill in the code below" - ] - }, - { - "cell_type": "code", - "execution_count": 155, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mean:\n", - " google_stock 347.420229\n", - "apple_stock 35.222976\n", - "amazon_stock 166.095436\n", - "dtype: float64\n", - "\n", - "median:\n", - " google_stock 286.397247\n", - "apple_stock 17.524017\n", - "amazon_stock 76.980003\n", - "dtype: float64\n", - "\n", - "std:\n", - " google_stock 187.671596\n", - "apple_stock 37.945557\n", - "amazon_stock 189.212345\n", - "dtype: float64\n", - "\n", - "corr:\n", - " google_stock apple_stock amazon_stock\n", - "google_stock 1.000000 0.900242 0.952444\n", - "apple_stock 0.900242 1.000000 0.906296\n", - "amazon_stock 0.952444 0.906296 1.000000\n" - ] - } - ], - "source": [ - "# Print the average stock price for each stock\n", - "print('mean:\\n ',all_stocks.mean(axis=0))\n", - "print()\n", - "\n", - "# Print the median stock price for each stock\n", - "print('median:\\n ', all_stocks.median())\n", - "print()\n", - "# Print the standard deviation of the stock price for each stock \n", - "print('std:\\n ', all_stocks.std())\n", - "print()\n", - "# Print the correlation between stocks\n", - "print('corr:\\n', all_stocks.corr())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will now look at how we can compute some rolling statistics, also known as moving statistics. We can calculate for example the rolling mean (moving average) of the Google stock price by using the Pandas `dataframe.rolling().mean()` method. The `dataframe.rolling(N).mean()` calculates the rolling mean over an `N`-day window. In other words, we can take a look at the average stock price every `N` days using the above method. Fill in the code below to calculate the average stock price every 150 days for Google stock" - ] - }, - { - "cell_type": "code", - "execution_count": 179, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2000-01-01 NaN\n", - "2000-01-02 NaN\n", - "2000-01-03 NaN\n", - "2000-01-04 NaN\n", - "2000-01-05 80.354167\n", - "2000-01-06 72.416667\n", - "2000-01-07 68.291667\n", - "2000-01-08 NaN\n", - "2000-01-09 NaN\n", - "2000-01-10 NaN\n", - "2000-01-11 NaN\n", - "2000-01-12 66.500000\n", - "2000-01-13 65.416667\n", - "2000-01-14 64.583333\n", - "2000-01-15 NaN\n", - "2000-01-16 NaN\n", - "2000-01-17 NaN\n", - "2000-01-18 NaN\n", - "2000-01-19 NaN\n", - "2000-01-20 65.229167\n", - "2000-01-21 64.541667\n", - "2000-01-22 NaN\n", - "2000-01-23 NaN\n", - "2000-01-24 NaN\n", - "2000-01-25 NaN\n", - "2000-01-26 68.062500\n", - "2000-01-27 67.000000\n", - "2000-01-28 64.479167\n", - "2000-01-29 NaN\n", - "2000-01-30 NaN\n", - " ... \n", - "2016-12-02 744.853353\n", - "2016-12-03 NaN\n", - "2016-12-04 NaN\n", - "2016-12-05 NaN\n", - "2016-12-06 NaN\n", - "2016-12-07 764.833313\n", - "2016-12-08 767.489990\n", - "2016-12-09 768.803324\n", - "2016-12-10 NaN\n", - "2016-12-11 NaN\n", - "2016-12-12 NaN\n", - "2016-12-13 NaN\n", - "2016-12-14 767.760010\n", - "2016-12-15 768.053345\n", - "2016-12-16 762.530009\n", - "2016-12-17 NaN\n", - "2016-12-18 NaN\n", - "2016-12-19 NaN\n", - "2016-12-20 NaN\n", - "2016-12-21 769.273316\n", - "2016-12-22 769.386658\n", - "2016-12-23 765.843343\n", - "2016-12-24 NaN\n", - "2016-12-25 NaN\n", - "2016-12-26 NaN\n", - "2016-12-27 NaN\n", - "2016-12-28 NaN\n", - "2016-12-29 769.560018\n", - "2016-12-30 762.383341\n", - "2016-12-31 NaN\n", - "Freq: D, Name: amazon_stock, Length: 6210, dtype: float64\n" - ] - } - ], - "source": [ - "# We compute the rolling mean using a 3-Day window for stock\n", - "rollingMean = all_stocks['amazon_stock'].rolling(3).mean()\n", - "print(rollingMean)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can also visualize the rolling mean by plotting the data in our dataframe. In the following lessons you will learn how to use **Matplotlib** to visualize data. For now I will just import matplotlib and plot the Google stock data on top of the rolling mean. You can play around by changing the rolling mean window and see how the plot changes. " - ] - }, - { - "cell_type": "code", - "execution_count": 180, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzt3Xd4FFXbwOHf2ZIChBQ6BAhIh0CCgPQoCKggCoqgotheC4riqyg2QF9RVKxYERX8RIqoNLFSBAQRkE7oNbSEQBICJNlyvj92s2RJ24RNdhOe+7pyZebMmTPPJpsns2dmzlFaa4QQQpRfBl8HIIQQomRJohdCiHJOEr0QQpRzkuiFEKKck0QvhBDlnCR6IYQo5yTRCyFEOSeJXgghyjlJ9EIIUc6ZfB0AQNWqVXVUVJSvwxBCiDJl/fr1J7XW1Qqr5xeJPioqinXr1vk6DCGEKFOUUgc9qSddN0IIUc5JohdCiHJOEr0QQpRzftFHnxeLxUJCQgIZGRm+DkX4iaCgICIjIzGbzb4ORYgyxW8TfUJCAiEhIURFRaGU8nU4wse01iQnJ5OQkECDBg18HY4QZYrfdt1kZGRQpUoVSfICAKUUVapUkU94QhSD3yZ6QJK8cCPvByGKx68TvRBClBcZFhuz1x3GF9O3SqIvxI8//ohSih07dvg6lAItXLiQ2NhY2rRpQ4sWLfjss88AmDt3Ltu3by9Wm8uWLaNfv36F1gkNDSU2NpbmzZvz8ssv51nv6NGj3HrrrcWKQ4jy4MsffuLaBR15ddLH2O2lm+wl0RdixowZdO3alZkzZ/o6lHxZLBYefPBBFixYwKZNm9iwYQNXX301cGmJ3lPdunVjw4YNrFu3jm+++Yb169e7bbdardSuXZs5c+aUaBxC+LP1mzYSodJRJ7aReCazVI8tib4A6enp/PXXX3zxxRduiX7ZsmXExcVx22230aRJE0aPHs306dPp0KED0dHR7N27F4AFCxZw1VVXERsby7XXXsuJEycAuOGGG4iJiSEmJobQ0FCmTZtGRkYG9957L9HR0cTGxrJ06VIApk6dysCBA7nuuuto3LgxzzzzTK44z5w5g9VqpUqVKgAEBgbStGlTVq1axfz58xk1ahQxMTHs3buXjRs30rFjR1q3bs2AAQM4ffo0AHv27OHaa6+lTZs2tG3b1vUasq1du5bY2Fj27duX78+rYsWKXHnllezdu5epU6cyaNAgbrzxRnr37s2BAwdo1aoVADabjaeffpro6Ghat27NpEmTAFi/fj1xcXFceeWV9OnTh2PHjhXr9yaEP6qtkgF40Tyd84l7C6ntXX57e2VOLy/YxvajaV5ts0Xtyoy9sWWBdebOnct1111HkyZNiIiI4N9//6Vt27YAbNq0ifj4eCIiImjYsCEPPPAA//zzD++//z6TJk3ivffeo2vXrvz9998opZgyZQpvvvkmb7/9NosWLQIcie3ee+/l5ptv5qOPPgJgy5Yt7Nixg969e7Nr1y4ANm7cyIYNG1wJfMSIEdStW9cVZ0REBP3796d+/fr07NmTfv36cfvtt9O5c2f69+9Pv379XN0m2Yk1Li6OMWPG8PLLL/Pee+9x5513Mnr0aAYMGEBGRgZ2u53Dhw8DsGrVKkaMGMG8efOoV69evj+v5ORk/v77b1566SXWrl3L6tWr2bx5MxERERw4cMBVb/Lkyezfv58NGzZgMpk4deoUFovFdYxq1aoxa9YsXnjhBb788ssi/maF8E+9a5yBU45llZ4IFJx/vKlMJHpfmTFjBiNHjgRgyJAhzJgxw5Xo27dvT61atQC44oor6N27NwDR0dGus/GEhAQGDx7MsWPHyMrKcrv/++TJk9x1113Mnj2b0NBQVq5cyYgRIwBo1qwZ9evXdyX6nj17EhoaCkCLFi04ePCgW6IHmDJlClu2bOGPP/5g4sSJ/P7770ydOtWtTmpqKikpKcTFxQEwbNgwBg0axJkzZzhy5AgDBgwAHA8mZYuPj+fBBx/kt99+o3bt2nn+nFasWEFsbCwGg4HRo0fTsmVL1q5dS69evYiIiMhV/48//uDhhx/GZHK8/SIiIti6dStbt26lV69egOOsP/vnK0R5YNJW17LdZindY5fq0YqpsDPvkpCcnMySJUvYunUrSilsNhtKKd58803A0T2SzWAwuNYNBgNWq+MXOmLECP773//Sv39/li1bxrhx4wBHEhsyZAhjxoxxdWcUdCU+57GMRqOr/YtFR0cTHR3NXXfdRYMGDXIl+vwUdOxatWqRkZHBhg0b8k303bp1Y+HChbnKK1asmO/xLr5VUmtNy5YtWb16tUcxC1HWKHuO5G63leqxpY8+H3PmzOHuu+/m4MGDHDhwgMOHD9OgQQNWrlzpcRupqanUqVMHgGnTprnKR48eTevWrRkyZIirrHv37kyfPh2AXbt2cejQIZo2berRcdLT01m2bJlrfePGjdSvXx+AkJAQzpw5A0BoaCjh4eGsWLECgP/7v/8jLi6OypUrExkZydy5cwHIzMzk3LlzAISFhfHTTz/x/PPPux3jUvTu3ZtPP/3U9Q/r1KlTNG3alKSkJFeit1gsbNu2zSvHE8IfGHIkepVxqnSP7UklpdSTSqltSqmtSqkZSqkgpVQDpdQapdRupdQspVSAs26gc32Pc3tUSb6AkjJjxgxXV0a2W265hW+//dbjNsaNG8egQYPo1q0bVatWdZVPnDiR3377zXVBdv78+QwfPhybzUZ0dDSDBw9m6tSpbmfyBdFa8+abb9K0aVNiYmIYO3as62x+yJAhvPXWW8TGxrJ3716mTZvGqFGjaN26NRs3bmTMmDGAI+l/8MEHtG7dms6dO3P8+HFX+zVq1GDBggU8+uijrFmzxuPXn58HHniAevXq0bp1a9q0acO3335LQEAAc+bM4dlnn6VNmzbExMSwatWqSz6WEH4jR9eN1RBcqodWhd28r5SqA6wEWmitzyulZgOLgBuAH7TWM5VSnwKbtNafKKWGA6211g8rpYYAA7TWgws6Rrt27fTFE4/Ex8fTvHnz4r8yUS7J+0KUVVGjfyJa7WNB4Ivs6vk5TbrddsltKqXWa63bFVbP064bExCslDIBFYBjQA8g+8boacDNzuWbnOs4t/dU8uy6EOIyV5mzmHD2zdvyvs5WUgpN9FrrI8BE4BCOBJ8KrAdStHZ9FkkA6jiX6wCHnftanfWreDdsIYQoW34PHMUdxsW0z/iY5NpxpXrsQhO9Uiocx1l6A6A2UBG4Po+q2X1AeZ295+ofUko9qJRap5Ral5SU5HnEQghRBpmxcp5AkgjDpjy7/uYtnnTdXAvs11onaa0twA9AZyDM2ZUDEAkcdS4nAHUBnNtDcT0mcIHWerLWup3Wul21aoVOYi6EEGXWb9uOY8ZGWIjjluOFm48Wsod3eZLoDwEdlVIVnH3tPYHtwFIge5SqYcA85/J85zrO7Uu0L4ZrE0IIP5H020RC1HmUMQCAmWsPsycxvdSO70kf/RocF1X/BbY495kMPAv8Vym1B0cf/BfOXb4AqjjL/wuMLoG4hRCizGhgOwCAMSCAHwPGsDjgKa5/f3mpHd+ju2601mO11s201q201ndprTO11vu01h201o201oO01pnOuhnO9UbO7fmPguXnjEYjMTExtGrVihtvvJGUlJQC6+ccuCvnEL/z589nwoQJXonpnnvuoUKFCq6HoACeeOIJlFKcPHnSK8cQQnjXiXTHw1Ib0yoTa9jDFYZjWGyl19EhT8YWIDg4mI0bN7J161YiIiJcA48VVf/+/Rk92nsfbBo1asS8eY6eMrvdztKlS11P4Aoh/Mv7386lmX0vWdrIH8F93LY1fO4nMq0lPxyCJHoPderUiSNHjgCOJ1FHjRpFq1atiI6OZtasWQXuO3XqVB577DHAcUb++OOP07lzZxo2bOgao91utzN8+HBatmxJv379uOGGG/Idv/322293HXPZsmV06dLFNUAYwDfffEOHDh2IiYnhoYcewmZzvJEeeeQR2rVrR8uWLRk7dqyrflRUFGPHjqVt27ZER0f7/SQrQpQVf+1O4oldw2huOEyAsvFss2TXtgNBd7Av8A5W//R1icdRJgY14+fRcHyLd9usGQ3Xe9adYrPZWLx4Mffffz8AP/zwAxs3bmTTpk2cPHmS9u3b0717d48PfezYMVauXMmOHTvo378/t956Kz/88AMHDhxgy5YtJCYm0rx5c+67774892/cuDHz5s3j9OnTzJgxg6FDh/Lzzz8DjidHZ82axV9//YXZbGb48OFMnz6du+++m/HjxxMREYHNZqNnz55s3ryZ1q1bA1C1alX+/fdfPv74YyZOnMiUKVM8fj1CiLw9981Slue44bx2HuP8hVkSSzwOOaMvwPnz54mJiaFKlSqcOnXKNYTuypUruf322zEajdSoUYO4uDjWrl3rcbs333wzBoOBFi1auCYjWblyJYMGDcJgMFCzZk2uueaaAtsYOHAgM2fOZM2aNXTr1s1VvnjxYtavX0/79u2JiYlh8eLFrslCZs+eTdu2bYmNjWXbtm1uM08NHDgQgCuvvNJt7HghRPHdZfvRbT2jau6ReLU1q8TjKBtn9B6eeXtbdh99amoq/fr146OPPuLxxx+/5Ml9cw5Wlt1WUdscMmQIbdu2ZdiwYRgMF/5fa60ZNmwYr7/+ulv9/fv3M3HiRNauXUt4eDj33HMPGRkZuWIqaBhkIYTnTp/N4oCu6Vpvm/EpfzdrwlZ7FK0MBwD42Nqf6lWuJraEY5Ezeg+EhobywQcfMHHiRCwWC927d2fWrFnYbDaSkpJYvnw5HTp0uKRjdO3ale+//x673c6JEycKHRK4Xr16jB8/nuHDh7uV9+zZkzlz5pCY6Pg4eOrUKQ4ePEhaWhoVK1YkNDSUEydOuLp6hBAl49Ple1lk60DvzDdoYZ/F+teHEGAycEDXcNV50zoEW1j9Eo+lbJzR+4HY2FjatGnDzJkzGTp0KKtXr6ZNmzauyUhq1qx5SV0et9xyC4sXL6ZVq1Y0adKEq666yjWrVH4eeuihXGUtWrTg1VdfpXfv3tjtdsxmMx999BEdO3YkNjaWli1b0rBhQ7p06VLsWIUQhauxfy4bgiaQSiVCxx1xlYcFGcE1NL0uldssCx2muDTIMMUO6enpVKpUieTkZDp06MBff/1FzZo1C9/xMnI5vi9E2fTCC08y3uyc83hcqqv8mQ+m8uapJwBYMXgbjWpXoVZo8can93SYYjmj9yP9+vUjJSWFrKwsXnrpJUnyQpRhriR/EaN2nM4vt0XT6YqqmAOC8qznTZLo/Yi3puoTQvhepjYTqHJPAh7uGO6G5TXu4iqDuVRi8euLsf7QrST8h7wfRFmgtSbTamONvRlpOpjPmrs/ENWlfVvetNzGLdd2JdBkLJWY/PaMPigoiOTkZKpUqYJMUCW01iQnJxMUVPIfc4W4FMM/WcCAY+/xivUBzgTWYNNg9+k7zgTV4WPbzfStHFlqMfltoo+MjCQhIQGZlERkCwoKIjKy9P44hCiOXsc+o7dxPekEM6vWi7m22+yOT6ZmY+l1qPhtojebzTRo0MDXYQghhMd2nzjD19beDDSuZKBxJQH2eUAntzpWux0Ao6H0eir8NtELIURZ89FnH/JpwGeu9TBbrsn1aFS9Eg/FNSS8QkCpxSWJXgghvCQi8wg1zadd62aVewjilrVDaVm74Ichvc2v77oRQoiyJAD32yltFfxjPmxJ9EII4SVXBl0Y6mC/vQapFaJ8F0wOkuiFEMJLqtgc03mm6Qpck/UuB2r08nFEDpLohRCiCFLPW4ga/ROz1h7KtW1GxHCSdGWuy3QMrV4nvHhj2HibJHohhCiCxLQMuhi28PWf23JtC67flq62yUx6pD8AocGlM8RBYeSuGyGEKIKA9AS+Mr/JwszrAPenXr9efRCANpGhbBrTm+CA0hnioDCS6IUQwkOvL4pn8Y5Emlge5WDFqxiYTz2T0UBoBf/pMJFEL4QQHrDbNZOX76GROsoi3ZF6VMhVZ5xpKvt0LaBv6QdYAEn0Qgjhgbd+28m75o+52biK5bZoptd6L1ednoYNhOl0H0RXMEn0QgjhgV/W7aSnctw+2d24he535Z7Yqa4hibr430CMkuiFEMIDY6yTaGfY5VpPP51IpfDqbnVetdxJCpWYWNrBFcJ/rhYIIYQfq2A/47aelHjMbf1EWgZTbH2ZY4srzbA8IoleCCE88Ln1wgXWj6z9adC0jdv27HHm+0bXKtW4PCGJXgghPPCY6UfAMYZN1TY35NqePdFl9yZVSzEqz0iiF0IID1iclzQfsTzJ8fDcF2Kz5zRW+N/Up5LohRDCA5nazDp7E3boeq5ZonJyzV3vf3le7roRQghPmJUNK44hDT5asouKJhtDOjYizDlT1P6TZwG/zPNyRi+EEJ6oHAAhFYJZ9vTVfFvxXTovu4OYV353bf902jTuM/6MUv6X6iXRCyGEB7Kysjhx1k5U1YoEBAZhxn2awO5qI8+aZmC35e7W8TVJ9EIIUYizGVkstcfwtc0xkYhdmTBjdatzSlciUFlJ2r/ZFyEWSBK9EEIU4kx6OiNNP9CpUiIAdoM5V6Jvb9gJQI3UTaUeX2Ek0QshRCFsmY4Lre0b1wHgwGkLJuXeddPL+C8Adc7mnpDE1zxK9EqpMKXUHKXUDqVUvFKqk1IqQin1u1Jqt/N7uLOuUkp9oJTao5TarJRqW7IvQQghSlbmeUeiNwY6pgZMJIwTOjzPuhX02VKLy1OentG/D/yitW4GtAHigdHAYq11Y2Cxcx0cU640dn49CHzi1YiFEKKUnbVoltnaoEPrAjDN2ofvbHF0MuQ+e88gsLTDK1ShiV4pVRnoDnwBoLXO0lqnADcB05zVpgE3O5dvAr7WDn8DYUop/xv8QQghPBRSrR5L2n1M5RaOi7HXBm7ndfMXzAgYDzieij2hwwCYXfUxn8WZH0/O6BsCScBXSqkNSqkpSqmKQA2t9TEA5/fs8TrrAIdz7J/gLBNCiDLpaOp5TqZnuib7HtCuvtv2+z5cyJ+2NjyUNZIurRr6IsQCeZLoTUBb4BOtdSxwlgvdNHnJ62kBnauSUg8qpdYppdYlJfnfQP1CCJEt4dR5Fm05TobVeY+8wey2/c7Et7nN9Cc11WkGto30QYQF8yTRJwAJWus1zvU5OBL/iewuGef3xBz16+bYPxI4enGjWuvJWut2Wut21apVK278QghR4uyuAcscDEb3RF/HOfPUEe1/I1eCB4lea30cOKyUauos6glsB+YDw5xlw4B5zuX5wN3Ou286AqnZXTxCCFEWZXdJGJzDGyijY8ybe7JGAfCDrRvb7PWJvfZ2X4RXKE8HNRsBTFdKBQD7gHtx/JOYrZS6HzgEDHLWXQTcAOwBzjnrCiFEmeU6o3ed0jvO6FuogySnZ/K5rR+f2/rxT/u6+bTgWx4leq31RiD3AMyOs/uL62rg0UuMSwgh/Eb2EMTZiV6ZgwC4wfgPG9/ow8PGpnxq60/1kCAfRVgweTJWCCEKsW3dcp40zcGQkQrAoZBYzupAVttb0NO4gdHmmXneU+8vJNELIUQhbMc28YTpB4yWdABCg83E6/ok6As3krwT8JmvwiuUTDwihBCFyL6rBufdNnXCg+mdNQ6AgcYVtDHsw6z8b3jibHJGL4QQhXjCOTG4AUcyb1IjhNcGRAPQxrAPACOS6IUQoswzVoy4sGyAeuqEa/2fgA6+CMkj0nUjhBCFWGtvQpY2c1VwJVdZ9VPrWR74JABvWW5jeZVh9PFVgIWQM3ohhCjAA9PWEUQWGQRgMl5ImcGWFAA+sN7MJ7b+xDXx3yf85YxeCCEK8Ef8Ce42h7hGp8yW/XTsgDse5vEWnXwRmsfkjF4IIfKRci6LA0F30N24hXMhDdw3GhznydpmzWNP/yKJXgghLvLy2+/AuFCWvDPMVdaIBLc6ypnov1m1r1RjKw5J9EIIcZHeKd8BMNC6yFX2feQzbnWyE/1/jr5YeoEVkyR6IYS4yMUTaJzRwbzQL9qtLLuPvppKK6Woik8SvRBCXGSSbYDb+iFdnWDOu5Upg7E0Q7okkuiFEOIiq+0t+cp64a74loaDmO0ZbnVsQeEst0XTL/PV0g6vyCTRCyHERaKqVOAMwW5lRnOg23pmeBPutjzH4Jv6l2ZoxSKJXgghLmLXYHemx4P26gCYLkr0Rufg9I2rV8LfSaIXQoiLaDQ/2roCUN/gmA7baHJP9AaDI9E/M2dz6QZXDPJkrBBCXKStdTNaJbrW7VphuOjiq9GgGGRchsVWB7imlCMsGkn0Qghxkf9aJnPO5OjwmGS9mRW2aGa7Jox1CK8QwFOm79hmuAoY6YMoPSddN0IIcREjNsCR2Lfb6/OPbp6rTqPqlQjCQmhIxVKOrujkjF4IIXI4cz6LSH3cdRr8SI/GfNTjhlz10jOtBGDhxDmVa5u/kTN6IYTI4WyW+0xRJqPZdeE1p8wsK4FkcTTdf2eWyiaJXgghckg+m8nAzHE8kvUEAErl/QRskNnIMMto4qv3Lc3wikW6boQQIodMi5UNuhEjm6bCASCfoQ4qBpl5/D8P0qxWSKnGVxxyRi+EEDkYk+LZHzSUWPt25to6Y6lYPd+6HRpEUDnIXIrRFY8keiGEyMGW5Ri87HRIY0ZaHiOrSgsfR3TpJNELIUQO2YnebnA8CWvM40JsWSOJXgghcshO9KbACjSpUYmIigE+jujSycVYIYTI4VRwFC9b7uL+NrH81q++r8PxCjmjF0KIHMJqX0Fii/uoGFHL16F4jZzRCyEua0dTzrNqbzI9m1XHYFDEHzvDh3fEolTZ75vPJmf0QojL2tYjqTz93SaOpJxnwg+rCf7lv7R67ntfh+VVckYvhLisHUw+B8DSHYk0iP+UO0xLuMJwFOwDwVA+zoUl0QshLmsGWwa3GJazc/FqPgz4CYCrDDt8HJV3SaIXQlzWKpjsvB3wae4N5eRsHqSPXghxmTME5p7zdWD1RT6IpORIohdCXNaCAtzHqllpa8kPw7v4KJqSIV03QojLmtloYKq1N7GGPWzq+gnNmzTxdUhe5/EZvVLKqJTaoJRa6FxvoJRao5TarZSapZQKcJYHOtf3OLdHlUzoQghx6bSGcdZ7OH/PH9zduyPtoyJ8HZLXFaXr5gkgPsf6G8C7WuvGwGngfmf5/cBprXUj4F1nPSGEuCS/bz/B4vgTXm839NRGPjdPpIb1qNfb9hceJXqlVCTQF5jiXFdAD2COs8o04Gbn8k3OdZzbe6ry9IiZEKJUbTh0mqjRP/HX9FfZNf0pr7cfeD6JXsZ/MWale71tf+FpH/17wDNA9lQqVYAUrbXVuZ4A1HEu1wEOA2itrUqpVGf9k16JWAhxWVmyPp7+hr8YZ/4agBW7k+jWuJr3DqCdc76Wo9spL1boK1NK9QMStdbrcxbnUVV7sC1nuw8qpdYppdYlJSV5FKwQ4vLT5Py/fBDwkWs95ZzFuwfIPl81lN97Uzz5F9YF6K+UOgDMxNFl8x4QppTK/slEAtkdXAlAXQDn9lDg1MWNaq0na63baa3bVavmxf/OQohyY+PhFFZt2+dWFn56k1ePcSY11bGQz9yw5UGhiV5r/ZzWOlJrHQUMAZZore8ElgK3OqsNA+Y5l+c713FuX6K1znVGL4QQhdkev53XzV8AsMLWCoAK5497pe1Wo7/jvk8Xs333LuxaERCa/9ywZd2lfFZ5FpiplHoV2AB84Sz/Avg/pdQeHGfyQy4tRCHE5Wp/2oXlf+zN6GbcSpYp95OsRXXDO0vYGvQAZP/PUFCzRu1LbtdfFSnRa62XAcucy/uADnnUyQAGeSE2IcRlLiAkgjX2Zli0kU5xfWDVHKqFhzNhUTw3tq5Oy8gqxWp3cup/8r6aWE6V38vMQogyb+uRNAZnjeHKl1Zwrk43GmZ8w7a0IEb/05EVnz5RrDbPZlqJVO43Ab5qudMb4fqt8nuZWQhRpllsdg7u3kxtzAQHGFEGA3YM1Fs2AgzQ1/B3sdo9m3aKiheVnazb59ID9mNyRi+E8Ds2u2bdvpMsC3yKXwOfBcDgfO6yhkoBIKVSg2K1ffS4o2P+D1usq+ztoV0vJVy/J4leCOF3Us5lkfi14+a9EHXeUejsU6+lHHdrr6451G0frTXrt2xj//Z1Bbd92tFtk958CMMbLWbbg4cwVipeX39ZIV03Qgi/Y7FpbjKuAmBxtWH0xJHnHzIuAGCatRc7Atu47ZN+PoMrv+/MEV0FXt5Hfrpd1ZGNQQvo3zKamyuGl9RL8CtyRi+E8DsWm53Z1jgAzgQ6HqiMqlKR58wzAEjSYfy5y/2J+l+XLAWgjkousO2v153g5h/OkJqrp778kkQvhPA7FpudU1QGIDHTMTFI9cqBru29jev41jLSbZ8eV/cEIEFX5fTZLE6fzcqz7ezHNy+noRal60YI4XcsNs0vtvaApkff2wE4nXaGCs7t4aQTqNzHvPkjPpFwW1vqmk7zymuvU53TvDr+vVxtXxiU6/LJ9HJGL4TwO7Zzpxlr/ppN9iuoWzsSgIqBAXzf9G2mt53JCcKprlLYsHW7a58sm533rLcwNutuJpvf4VXzV9jtuUdfcY3IcvnkeUn0Qgj/Y8s6T6xhDyM7RxAc4BhsLCykIrfc/gB39r+edB0MwNvfzmfH8TTW7Etmxfwv6W1cT5i+MG6CJctxx86Mfw7x+XL3C7SGyyjRS9eNEMLv2CyO/nWDMSDP7UvrPMTVx4fTVu3m4yW7aLH9PT4LcNyRs9Me6aq34LfF3Nr/Rr75cT6pVOI/3Rtid57RX07zIckZvRDC7/zwzx4Azum8z0Vv6d4WgP+a51D/8FweNi1wbQtVZ13LhrWfcuDkWT4yf8Ao0yy01lyGPTeS6IUQ/iclS/GttQeZEU3z3G4IrOBaDrOnsNR24Z76DB3AHu2Y8G6gcSW/btpPlOEENxlXcWBPPHWTV/Kp+V1UVlqudssrSfRCCL+ycMMhGh35kam2PjRqdVWedQzBFx50alK3Fk0Nh3nPOpCJlkFEGU6g1YXU1uHPYa4+h2n9AAAeV0lEQVTlzJMHqHzuENcZ16Ls9pJ7EX5GEr0Qwudyzk3UeW4nHjfN5bfAZwmypuZZP6rqhTP6bTSktjpFXPtYroisBcAeW02+7fIrALGGPa66WedSOZuRCYAqxzNKXUwSvRDC5575bhPNX1wIQIRKd5UbTIF51g8yGYnK+JaojOkE7JgLgE4/iS3T0T9fw5DGkJ5XcdjuPk3pm4sP8u9+x1g3yiiJXgghSsWa+P28tT2OhYanSc+0um0LDM57mAKDQXFjm9q8ZprCfaZfADhAbQzdnuCWzLFkDP4Og0FR1+A+TEJvwzrXMApmk7kEXo1/kkQvhPCpI2ccfeVXGI7x45dvuG1TxvyT8RM9G3GHaalr/ZounahbJYTqLeNoUMcx/+tuu+Oi7H57DQBaG/a66hsCgr3zAsoASfRCCJ+KytrlWu56bBoAFm1klOXBAverWulCt85JXZnwqDa0j4rgk6FXUivUkcS3tHoGgAaGEwDEGBwPTW1XV3jvBZQBkuiFED6lMy/0yWcn5Lsto+lz59MF7lchwOTqg//CekOedWq27edaHm+5w7W8PaB1seMtiyTRCyF8KuOs486aVH3hTprXnxzOtS1qFLifyaD4zuYYyviukePzrHMuI4tkHcLskGEMfuIt+mROAODPM3W8EXqZIYleCFGith9NY/baw1hsed+3vl015iXjE+zVtQH41tqDqGqVCm3XYFBUjr6OcZa7qR1eOZ9KRq7M/Iz4Jg/RqHolRgzqw3xbJ5IIK/brKYtkrBshRIlaujORt37dyU2xtXNtu2/SAtSxDRyJ6IrJep627OEKw1GP235gyCD04FvzHVy+Td0wJgyMJq6po4unX9uGLK34Nf/XqGrxXkwZJYleCFGiEvdvpadhM/sTO/HzpgSe6BNNWoaFkCAzgxLf5/qAtSxM7Ui///3K/144S2alSPJ+HjZvBQ1OVi0kkCEd6rmVXdO0ejFfSdkliV4IUWLSzmUw9MDzNA44wspPfuFJ4zaeXfkfVtlb0L1tG8Yb1wLQOPgMAC+N/9iX4ZZbkuiFECVm9abt9DEcAaCrcRsAb5g/d2zcdqHetjq3kffwZcIb5GKsEMIr0jIsuS64mk/vzaf2BXNtnel888MlFZZAEr0Qwgvij6VhfT0K8//Cmfh/PwKwee9hjq+azkNZTxa4b+9nvqVmaFBphHnZkkQvhLhk0/7c5hqMrPLO7wBInzeKO0xLiTXs5ntb1zz3+6fDB1QICc9zm/Ae6aMXQlyyfmqVa/lB00/s3LOXzmk/AxDf8F5admvD7NQMdv44gTjDJloZ9hOh0ulw3V2+CvmyIoleCMGynYn8EX+CF/u2IMhc9OF7I7d95tY/cHzXWtfF1StqhNOtseM+9qONJmI0KHZPjOOMPZhrDdKpUBok0QtxmVu6I5H7p67BjuKRqxtRJ6xoozqeTEkjyjlGTbadG5YTBzyWNQKdcuE+99rOtpf2nU1Fk/uQxKLkyL9TIS5z905dy/vmDzkQdCc/zZ1RpH33JJ7hx4kPAbDI1oH3rAMBWJzekFGWBxl29/08cW3jXPsNuao+N155eY0g6UtyRi/EZe5V0xfcaPwbgPW7DhVYNz3TytlMKzUqO+6S+WjeCt41LQLgqkc+p7kpgnHvV+J18+cMtb7EW80alGzwwiNyRi/EZW6oabFrubI6W2DdXyc9xsF3ryXLamfKin2s3nvSta1KjUhOp6Yxzvw1DQ3HCdN5z/cqSp8keiEuQ9pm5USKe1J/MOtJKl91d4H7ZaUcp4Pewpp5n3D6l9eZYJ7CXnstXmu1CIwmWtSv6arbz/kpQfieJHohLkN//L6QGu/V5ofvv3WVTQ54l6anFpOWYcl3v8PaMSBYty3PM8o8m6uNm7jCcIzHujsGDgs0G+mYMQmAMM6U4CsQRSGJXojLzKZtW6mzagwA6/5d57bttgNjmTRxbL77TrP1zrPcGBwCOEaS/N/dfXjDMgRDs+u9FLG4VHIxVojLzMmti+lpOAjAa+Yvcm0fbfkYeC3PfUNDwyEzd3mFSqGu5V4tatBr/GdeiVV4R6Fn9EqpukqppUqpeKXUNqXUE87yCKXU70qp3c7v4c5ypZT6QCm1Rym1WSnVtqRfhBDCc59syT1++/vO2yIBjErnu68GRmQ9BsB6mrNq6F6Ojjxe4Jjwwvc86bqxAk9prZsDHYFHlVItgNHAYq11Y2Cxcx3geqCx8+tB4BOvRy2EKJIz5zL46sXbWPznMp6ssoY0XYE0HcxmewNGZg2n7+MfsNHuuK99a3C7XPuv2nmUJ55/jq8yRnJn6BY+t/YlLe5/dG5U1fUQlPBfhXbdaK2PAcecy2eUUvFAHeAm4GpntWnAMuBZZ/nXWmsN/K2UClNK1XK2I4Twge+mTOA+06/sX7qV1IAaJJrrUNVylObqEBVa9aVR9RC6Wh7nDdNkMOQeZGzN1y/yfsD3AKwPasF9o6ZjNMhZfFlRpIuxSqkoIBZYA9TITt7O79nzc9UBDufYLcFZdnFbDyql1iml1iUlJRU9ciGEx3qd/AaABhxhmqUHO1s/Q5g6i1nZaHZ8PgAJuhpDLc9hTzvGtA9fZv3BUwz78h+Op2ZgbXuvqy27MkmSL2M8TvRKqUrA98BIrXVaQVXzKMvV6ae1nqy1bqe1bletWjVPwxBCFGLexiOMm7+NGWsOYLE6xpPJxOza/q6eiDlxExvsjQDonLIAgFWje1CVVLoZtzLs5DscmjKUaYd6cfeEqVx55GvX/qHW5FJ8NcIbPLrrRillxpHkp2utf3AWn8juklFK1QISneUJQN0cu0cCnk/rLoQotjNnUon7sT03OZ9w3Wn8nvptriGdYPbaa3GFwdGDWuPYUn6r/TCxx58mg0DAMeBYmHO/721ducW4EoDfAp/laHKE6xQuOG1/Kb8qcak8uetGAV8A8Vrrd3Jsmg8Mcy4PA+blKL/befdNRyBV+ueFKHnWtERC3q7nStYApw/Fs/qVa4gx7CVBX/jkvK7RSOJaRAKQFnJhcLFunbvxSNYTtFb7SdRhrvLa6pRreUk7ub+irPGk66YLcBfQQym10fl1AzAB6KWU2g30cq4DLAL2AXuAz4Hh3g9bCJFT/NEUHpjwea7ybcfPco1xEwBbdRSft1/EaMsDDO17NefDGjM06zm+CXvEVX/MjS1objhIY8MRqqsUt7besw5k7k3bufP6q0v0tQjv8+Sum5Xk3e8O0DOP+hp49BLjEkIUwbfLtzE14M1c5f1OfOL6672q732069QF+nYBwBhsYKU9mt6BYW77VLiiKxycC8ACW0fXyJaPjfkEU4DM7VoWKUde9q127drpdevWFV5RCJHLU+Ne5m0u9Kr+3HwC18ePdqvzU7M3uGHwQ24PNllsdrYdTaN2aBDVK19I4KfPZhH+lqObJ+Gxg0RWDUNrLQ9F+SGl1Hqtde4HHy4iQyAIUYYlp2e6kvxaexNqP/knUeez+HjLKq4z/ENDw3EAqrfulStRm40GYuqG5WozvGIAOwb/hQoKoWlVx3ZJ8mWbJHohyqgjKefpPuF39jpPxu0YqBNegTrhFYh88UuSU8/CJ/UBiG5Ur0htN2veytvhCh+S0SuFKKNm/7KEvUF3udarc9q1HBJkJqpGGP/aG3FKVyIowJxXE+IyIWf0QpRRTS07XMubAtpCRO5p+1qPXVuaIQk/JYleCD/26Df/ENesFre1q5tr25mdy11/wa2f/Q1lzH3WbjLKh3YhiV4Iv3X06GE+2tOLhN1Vod3eXNvbm3YDYBuTImPPiALJv3shfOzdSW/z/uTJ7NvvPrTAhx+9C0CkOplrn8TU8zTkCDvsdSXJi0LJGb0QPmSza55MfsWxMg146SQYzSSfOuU2+9OZ81mEBAe41v/4bR53AMkNbizdgEWZJGf0QvjQuy/9x219/Jvjsds1ge83dyv/+IsLU/NprQlL2Q5AcKMuJR+kKPMk0QvhI5lWG0+bv3MreyHzXWbNm0slleFW/uzJF/lqzo9ou51dY1txw5H3AWgR07nU4hVllyR6IXxk/OTpAOy118KqL/wp9t44wrW8Im6Ga/nerfew5ZUONDUkuMoCK4SUQqSirJNEL4SPXHNsCgAJLR4i47kTvFtxJABV1BlHhZeSiWpzNbvtFyZoa81u1/JoywN53lIpxMUk0QvhI7u1Yzx4Q6UIKgUF0PW62922Z1qyqBtRgfVdPmWtvYnbtoW2q3j91YmlFqso2yTRC+EjXwQOY2jWc3Tu40jw7aOb8aZzLp/fW7xOYFAFAIb06U7zF1bzi609AFvsUcQ99a0MNCY8JrdXCuEjFYIDiWjUB6P5wm2Tz4z7APiAXhfVrRRo4oiuCoDhhjcJCataeoGKMk/O6MVlI8NiIz3T6uswXHpaltLy7BqP60cOeoPR9WdQL6ZHCUYlyiM5oxeXjehxv2KxaQ5M6IvWmoTT56laKZDgAGOpx5JhsfFi5ntsTL0aeNijffq0qU+fNvVLNC5RPskZvSj37FkZJI6tz27z7YwzTWXpr3NZMOZ6+r65kJ+3ls689emZVqatOoDWmvQMC0HjIwCIObOsVI4vLm9lOtGvO3CKd37bidVm93Uowo8t+m2Ra6Lre0y/cc3qYfQ3rmZWwP/YtP94oftbbHaW/rMBu73o026eTM8kM+Msb838lfCfH+b3jXs59dqFp17f0XcUuU0hiqpMJ/p/D53mgyV7OJB8lnNZ/tP3KnzPZtfM+/xlErb9Rb919+ZZp7nhEC03vJLntlNns1i2M5EzGRbmzf+eaxZdzRuvPOnx8VfsTuKXrcfQbzUicEJtXt5/B/2Nq+k970rqGZIAOKcDGTn246K/OCGKqEwn+vDMowwyLmPIOwvoMeZbX4cj/MjRU+ncdOQdTsx6wlW2bsAK13Kmdlyeus30p6tMa80HLw6DcaFEvFWNq2c0JvP1hlRvGA3Ac3zFgOffJ/W8pcBjHz51jgbfdOS6Oc2optLyrXf8sX0YZORJUQrKdKKvfWYLb5knsy7oEf4OGlH4DuKycfJ0MgBXGhxPkr4e8DgxrVpxTDv6xm+uPIuN9oYAfPHiEDYdSOSjl4bxuGmuWztVVRrdf7zKtf5jwBjOpSbne9yUc1nsf7d3nkML5/Sl9XoaVqtU9BcmRDGU6USvzEFu689++h1NR//IkZTzPopI+No7c5awc0xLYqe3cSsf/tgoTEYDs2xXk6YrMPuBtpzq/ioA95t+ps3UxjxmmufRMZasWp3vthVLf6G7cYtb2UldGYBnTKNJGr6LDVX6cstDY4rysoS4JErrol9g8rZ27drpdevWFXm/Tz7/hEeOjM5V/kvrD7hu4DBvhCbKkJOHdlD1y6tylX9Z5WnuG/FSrnKr1Yrp1Sp5tnWeQEZWeI3Pzj0FwOQaY1mUVIW59sfJ1CYCX3Y/qz986hwHk8/RdfoVrrJZEY9w9OQpho/5hKQzmdQJC5anWYVXKaXWa63bFVavTJ/RB6i8L8BGbXyrlCMRvpZhsTHpM/cLm09lPcyRkcfzTPIAJpOJn/uuZl2OcWQmNJnJmWcTCR6XyKej7neV94vrxOzn7wIgUFmxXHSn1zfvPeOW5Bf0Xc/gxyfw5CuTCTQZiQyvIEle+EyZTvS33pn3gybNDIfp/9wHfPvLn2RYbKUcle/M/HEuk956AXJ+SrPb0bbyf0fSgncf4WXzNACSHt7CsfvW8/Zrb1AnLLjA/a5v34KNLR2fCpN0ZUbfcT0hwYEAKKVYevtu5vTbTO0WnQgwGXjfOpAsbeTHdY574rP15m/X8n57DW5s38jbL1GIYivTiT402MysGzbTSs9mVs+/WNjjd1bpVgDMD3yJjqse5MW5W30cZemwWm0M2TSMEWc/hJfDWPBPPJt374dXwlH/y7t7AuD4vi1knj9TipGWjAo2x90tSTqUajXrUaue54l2YL8beav1Qo7etzHXtmuaVufWdheeRg2pWIEAZeO2n2OZ+eU7jnvsJwxkt70O6TqIHfa6fBk7+9JfkBBeVOaHQBjcoT6DO1z4Q/ztzwhwnsQ3NBxn4rbu6FtOowxl+n9aoT6d+iWP5Vi/cVFHt+1ZVjsBpgs/g3937KXtzLbUzC4Yl1pisWm7nf1bV1MhJIyaDVqWyDEqh9fAesxAtZcPFXnfiIoBjBrYzaO6DVp3hbXfAGDYvxzz/17hGgATLA/oTvfnF/C/IkcgRMkq84n+YkZyX1zOTDlGUEQd7HZNUuJRalSvBeUk8dsyz7Fu/DU8ZtgBQJoOprLKfdfR7Pefpt71T9J9tuMTT9uLtu/e/DeNW3fMtR84Hj7KZizgvu9jSSfZ9uf3tO8xkCNnNV8v+IMTJ47xlXqFhjnqJT91nCohBXepFFVQ6h4sylzib+h6MT1hrWN5sGmZ+7aMnSV8dCGKp0zfdZOX+z/8iYQjh2hv2Mmr5q8AmG/rhLHXWDLWTOWWszP53taVga8sLPMXxxb/vZbIRfe4TS2nx5xm5jsjiUxdTwYBpNfuwoATkwpta7m9DW1GzsHwfmuSqnUk8j8zOX4qlYggTaX3m7rq2Z87iiGwYt6NjAv1PPgifoJIOhjP7M9f4/ohj1I7qhlBlcI4cPgQJ44coErlyjSaHVesdotKa83UlwZzr+lXV1mfzAn8Gjiazbf8SevomBI9vhA5eXrXTblL9BabHQVYMs4x768NDFnVL896S6LfIPXkCQbcPxpMgV45dmmwWG3Y7Jqs8XWprM65ylcFdaf5vR8RXqOeW/0si41lr/Sit3F9nu1lvpBM4Pj8+/Avdui2X6lUpwURoY57w202G1kWK7bMdCq92zDf/Y4PXcaef36h664JrrK17d5m55EkBt5yJ6bQOhw7cpAfv3yDzoOepEN0M1e9pP1bqData6GxbbQ3JOaVDR6/lkuxbkx72hl2sc7ehHavrC2VYwpxscs20ed05nwWIW9UK7BOwq0LiWzlWf+sr2mtOT6uIbXUKbfyg/bq1H9ldz57OWzZsYMmM7qwtOHTqJg7OTj3f8Tc8hTtWzZFvRzm1Th/bvIKdSKjsKYcoe2/z7FEX0mPl5cA8NYbYxl1/r1C21g/cAUNGzZl04p5XL3mP54deGwKlNKntA9ff4rHMqfwWcNJPHT33aVyTCEuJokex9n9tLF38IDpZ1dZwtCVRH5z4exwacvxxN3yqF+POZJ0MpnAoAAsbzW/MHG003dh93PTo28RYC7+mOq79+2l8ddt2WuvRb1n/mLSxx/w33OOZJzw0E4iqlRl/abNdPvpmkLbOjHyKDXC8unaATKtNjYvn8eVf96HQRXtvbdtWDyNA5P5fcMerv3nP3xm60ulFr2pV9nEtf0GF6mtS3Voz1a2L5zE1UOfJ6iqjBEvfEMSvdPB5LNMnTmLsUlPckRXoc7L+zg1tg4RKt1VZ4WhPd3G/FEixy+KDfuOsuvgUW6La+u6SyjpdCrV3nfvjvmu4u20v+tVomqW3HRyR/fvoHaDZm5l2m4n81waq757lxNH9nOj5Vd2tRtHkx53sf23r2jebQAhVSM9PobWGqUUs2dOpeLO76nZfgCVajai6fwbc9X9rNoLPPToM5f8uoQoTyTR52Cza1LOZlClghmMJma/2J/bTH9yXIdTU50G4Lsef7J3x0ZGDBtKxUDv37txYO9OzIFB1KldN9cdP7bMc/yzbg2dfr+50Ha2dPmQ6F53eT0+v5Ljoq7txZMYTWYfBiOE/5JEX4Cd2zex+PvPuP6uZ2gw1X3wq9X1H6bTvW9gsWSx+pUeVFcp1Fcn+PeGn9i4YBLmVjfx4JBb821ba01CUgpb/13JnpVzGPLQ8zDlWrfhav+tfx9hPUZycudqOqx6yKOY17R9kxRjFfr0zf/Y5YbNStr5DEIqVCj3zz8IcSkk0XtoZ/wWms5yv6NjhvUabjSuppLKyHOfrTf+RKsrL+yTdi6DFZP+Q0p4NN0SJrsmliiOI0OXc8uUTYSrdF7uUZVAZaVJlwEEB3v3vnMhRNnn00SvlLoOeB8wAlO01hMKqu/LRK/tNuaN7UecYTPhOfrtPZGkKxc4sUROfwfHUX3YVH6Y9AxPm79z2zbLejV9RnxIWI26RTq+EOLy5rNEr5QyAruAXkACjucIb9dab89vH18m+pysNjtbX+tOjM0xnvg+e01qvbCN06mn+X3e/9Gz7xAiJzcvpBU4bKyLYfD/UbtxDGdTTlAxJByV4159W+Y5Dp5MJapmDQxG6ZoQQhSPLxN9J2Cc1rqPc/05AK316/nt4y+JPqc9x07RIMyIMTj3054ZyYfZ++UDtDx7YcTCY3cso1aTWMeK1qV2P7cQ4vLlaaIviaFB6gCHc6wnALlmg1BKPQg8CFCvXr2LN/tco1oR+W4LqlKXlqN+dSurlXNFkrwQwo+URL9BXlku18cGrfVkrXU7rXW7atUKfnpVCCFE8ZVEok8Acl5VjASOlsBxhBBCeKAkEv1aoLFSqoFSKgAYAswvgeMIIYTwgNf76LXWVqXUY8CvOG6v/FJrvc3bxxFCCOGZEpmnQWu9CFhUEm0LIYQoGrmJWwghyjlJ9EIIUc5JohdCiHLOLwY1U0olAQeLuXtV4KQXw7lUEk/BJJ78+VMsIPEUxh/iqa+1LvRBJL9I9JdCKbXOk0eAS4vEUzCJJ3/+FAtIPIXxt3gKIl03QghRzkmiF0KIcq48JPrJvg7gIhJPwSSe/PlTLCDxFMbf4slXme+jF0IIUbDycEYvhBCiAH6X6JVSdZVSS5VS8UqpbUqpJ5zlEUqp35VSu53fw53lSin1gVJqj1Jqs1KqbY62hjnr71ZKDfNlPEqpGKXUamcbm5VSg33983Fur6yUOqKU+tDX8Sil6imlfnO2tV0pFeXjeN50thHvrFOkiQaKEUsz53skUyn19EVtXaeU2umMc3RRfy7ejCe/dnwVT472jEqpDUqphb6ORykVppSao5Ta4WyvU3Fi8hqttV994ZjDo61zOQTHtIQtgDeB0c7y0cAbzuUbgJ9xjIPfEVjjLI8A9jm/hzuXw30YTxOgsXO5NnAMCPNVPDnaex/4FvjQl78v57ZlQC/nciWggg9/X52Bv3AMzGcEVgNXl3As1YH2wHjg6RztGIG9QEMgANgEtCiFn01+8eTZjq/iydHef53v5YWl9F7ONx5gGvCAczmAYvyte/PLZwcuwg9/Ho75Z3cCtXL8QnY6lz/DMSdtdv2dzu23A5/lKHerV9rx5NHOJpyJ31fxAFcCM4F7KGai9+LvqwWw0o/eP52A9UAwUAFYBzQvyVhy1BuHe2LtBPyaY/054LmS/tnkF09+7fgyHhzzXiwGelDMRO/F31dlYD/Oa6D+8OV3XTc5OT+6xwJrgBpa62MAzu/VndXymrqwTgHlvoonZzsdcPyX3+ureJRSBuBtYNSlxOCteHB84klRSv3g/Pj9lnJMNO+TeLTWq4GlOD55HcORaONLOJb8+Oq9XNR2fBnPe8AzgP1S4vBSPA2BJOAr53t5ilKqojfiKi6/TfRKqUrA98BIrXVaQVXzKNMFlPsqnux2agH/B9yrtS72m9IL8QwHFmmtD+ex3RfxmIBuwNM4Pg43xPFJwyfxKKUaAc1xnCnWAXoopbqXcCxFirE4sXgpHr9qRynVD0jUWq8vbgzejAfHe7kt8InWOhY4i6PLx2f8MtErpcw4ftDTtdY/OItPOJNkdrJMdJbnN3Wh16Y09FI8KKUqAz8BL2qt/y5OLF6MpxPwmFLqADARuFspNcGH8SQAG7TW+7TWVmAujj8WX8UzAPhba52utU7H0Y/fsYRjyY+v3stFbcdX8XQB+jvfyzNx/FP+xofxJAAJWuvsTzlzKOZ72Vv8LtErpRTwBRCvtX4nx6b5QPadM8Nw9J9ll9+tHDoCqc6PV78CvZVS4c6r5L2dZT6JRzmmVfwR+Fpr/V1R4/B2PFrrO7XW9bTWUTjOor/WWhf5rMOLv6+1QLhSKnuAph7Adh/GcwiIU0qZnH/8cUCRum6KEUt+vDI9p7fiKaAdn8SjtX5Oax3pfC8PAZZorYf6MJ7jwGGlVFNnUU+K8V72Kl9fJLj4C+iK42PpZmCj8+sGoAqOiy27nd8jnPUV8BGO/u4tQLscbd0H7HF+3evLeIChgCVHGxuBGF/+fHK0eQ/Fv+vGm7+vXs52tgBTgQAf/r6MOC7UxuP4I32nFGKpieNsMA1IcS5Xdm67AcddIHuBF0rpd5VnPPm148ufT442r6b4d9148/cVg+MC/mYcn06LfMefN7/kyVghhCjn/K7rRgghhHdJohdCiHJOEr0QQpRzkuiFEKKck0QvhBDlnCR6IYQo5yTRCyFEOSeJXgghyrn/B/P+PU9LjFpnAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# this allows plots to be rendered in the notebook\n", - "%matplotlib inline \n", - "\n", - "# We import matplotlib into Python\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "# We plot the Amazon stock data\n", - "plt.plot(all_stocks['amazon_stock'])\n", - "\n", - "# We plot the rolling mean ontop of our Amazon stock data\n", - "plt.plot(rollingMean)\n", - "plt.legend(['Amazon Stock Price', 'Rolling Mean'])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [default]", - "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.6.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Pandas/Statistics-from-Stock-Data.ipynb b/Pandas/Statistics-from-Stock-Data.ipynb index e537629..c4f477a 100644 --- a/Pandas/Statistics-from-Stock-Data.ipynb +++ b/Pandas/Statistics-from-Stock-Data.ipynb @@ -1,1443 +1 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Statistics from Stock Data\n", - "\n", - "In this lab we will load stock data into a Pandas Dataframe and calculate some statistics on it. We will be working with stock data from Google, Apple, and Amazon. All the stock data was downloaded from yahoo finance in CSV format. In your workspace you should have a file named GOOG.csv containing the Google stock data, a file named AAPL.csv containing the Apple stock data, and a file named AMZN.csv containing the Amazon stock data. (You can see the workspace folder by clicking on the Jupyter logo in the upper left corner of the workspace.) All the files contain 7 columns of data:\n", - "\n", - "**Date Open High Low Close Adj_Close Volume**\n", - "\n", - "We will start by reading in any of the above CSV files into a DataFrame and see what the data looks like." - ] - }, - { - "cell_type": "code", - "execution_count": 140, - "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", - "
DateOpenHighLowCloseAdj CloseVolume
02004-08-1949.67689951.69378347.66995249.84580249.84580244994500
12004-08-2050.17863554.18756149.92528553.80505053.80505023005800
22004-08-2355.01716656.37334454.17266154.34652754.34652718393200
32004-08-2455.26058255.43941951.45036352.09616552.09616515361800
42004-08-2552.14087353.65105151.60436252.65751352.6575139257400
\n", - "
" - ], - "text/plain": [ - " Date Open High Low Close Adj Close Volume\n", - "0 2004-08-19 49.676899 51.693783 47.669952 49.845802 49.845802 44994500\n", - "1 2004-08-20 50.178635 54.187561 49.925285 53.805050 53.805050 23005800\n", - "2 2004-08-23 55.017166 56.373344 54.172661 54.346527 54.346527 18393200\n", - "3 2004-08-24 55.260582 55.439419 51.450363 52.096165 52.096165 15361800\n", - "4 2004-08-25 52.140873 53.651051 51.604362 52.657513 52.657513 9257400" - ] - }, - "execution_count": 140, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We import pandas into Python\n", - "import pandas as pd\n", - "\n", - "# We read in a stock data data file into a data frame and see what it looks like\n", - "df = pd.read_csv('./GOOG.csv')\n", - "\n", - "# We display the first 5 rows of the DataFrame\n", - "df.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We clearly see that the Dataframe is has automatically labeled the row indices using integers and has labeled the columns of the DataFrame using the names of the columns in the CSV files.\n", - "\n", - "# To Do\n", - "\n", - "You will now load the stock data from Google, Apple, and Amazon into separte DataFrames. However, for each stock data you will only be interested in loading the `Date` and `Adj Close` columns into the Dataframe. In addtion, you want to use the `Date` column as your row index. Finally, you want the DataFrame to recognize the dates as actual dates (year/month/day) and not as strings. For each stock, you can accomplish all theses things in just one line of code by using the appropiate keywords in the `pd.read_csv()` function. Here are a few hints:\n", - "\n", - "* Use the `index_col` keyword to indicate which column you want to use as an index. For example `index_col = ['Open']`\n", - "\n", - "* Set the `parse_dates` keyword equal to `True` to convert the Dates into real dates of the form year/month/day\n", - "\n", - "* Use the `usecols` keyword to select which columns you want to load into the DataFrame. For example `usecols = ['Open', 'High']`\n", - "\n", - "Fill in the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 141, - "metadata": {}, - "outputs": [], - "source": [ - "# We load the Google stock data into a DataFrame\n", - "google_stock = pd.read_csv('./GOOG.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])\n", - "\n", - "# We load the Apple stock data into a DataFrame\n", - "apple_stock = pd.read_csv('./AAPL.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])\n", - "\n", - "# We load the Amazon stock data into a DataFrame\n", - "amazon_stock = pd.read_csv('./AMZN.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can check that you have loaded the data correctly by displaying the head of the DataFrames." - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "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", - "
Adj Close
Date
2004-08-1949.845802
2004-08-2053.805050
2004-08-2354.346527
2004-08-2452.096165
2004-08-2552.657513
\n", - "
" - ], - "text/plain": [ - " Adj Close\n", - "Date \n", - "2004-08-19 49.845802\n", - "2004-08-20 53.805050\n", - "2004-08-23 54.346527\n", - "2004-08-24 52.096165\n", - "2004-08-25 52.657513" - ] - }, - "execution_count": 142, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We display the google_stock DataFrame\n", - "google_stock.head()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 143, - "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", - "
Adj Close
Date
2000-01-0389.3750
2000-01-0481.9375
2000-01-0569.7500
\n", - "
" - ], - "text/plain": [ - " Adj Close\n", - "Date \n", - "2000-01-03 89.3750\n", - "2000-01-04 81.9375\n", - "2000-01-05 69.7500" - ] - }, - "execution_count": 143, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "amazon_stock.head(3)" - ] - }, - { - "cell_type": "code", - "execution_count": 144, - "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", - "
Adj Close
Date
2000-01-033.596616
2000-01-043.293384
2000-01-053.341579
\n", - "
" - ], - "text/plain": [ - " Adj Close\n", - "Date \n", - "2000-01-03 3.596616\n", - "2000-01-04 3.293384\n", - "2000-01-05 3.341579" - ] - }, - "execution_count": 144, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "apple_stock.head(3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You will now join the three DataFrames above to create a single new DataFrame that contains all the `Adj Close` for all the stocks. Let's start by creating an empty DataFrame that has as row indices calendar days between `2000-01-01` and `2016-12-31`. We will use the `pd.date_range()` function to create the calendar dates first and then we will create a DataFrame that uses those dates as row indices:" - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "metadata": {}, - "outputs": [], - "source": [ - "# We create calendar dates between '2000-01-01' and '2016-12-31'\n", - "dates = pd.date_range('2000-01-01', '2016-12-31')\n", - "\n", - "# We create and empty DataFrame that uses the above dates as indices\n", - "all_stocks = pd.DataFrame(index = dates)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# To Do\n", - "\n", - "You will now join the the individual DataFrames, `google_stock`, `apple_stock`, and `amazon_stock`, to the `all_stocks` DataFrame. However, before you do this, it is necessary that you change the name of the columns in each of the three dataframes. This is because the column labels in the `all_stocks` dataframe must be unique. Since all the columns in the individual dataframes have the same name, `Adj Close`, we must change them to the stock name before joining them. In the space below change the column label `Adj Close` of each individual dataframe to the name of the corresponding stock. You can do this by using the `pd.DataFrame.rename()` function. " - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "metadata": {}, - "outputs": [], - "source": [ - "# Change the Adj Close column label to Google\n", - "google_stock.rename(columns={'Adj Close': 'google_stock'}, inplace=True)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 148, - "metadata": {}, - "outputs": [], - "source": [ - "# Change the Adj Close column label to Amazon\n", - "amazon_stock.rename(columns={'Adj Close': 'amazon_stock'}, inplace=True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 149, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "\n", - "# Change the Adj Close column label to Apple\n", - "apple_stock.rename(columns={'Adj Close': 'apple_stock'}, inplace=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 150, - "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", - "
google_stock
Date
2004-08-1949.845802
2004-08-2053.805050
2004-08-2354.346527
2004-08-2452.096165
2004-08-2552.657513
\n", - "
" - ], - "text/plain": [ - " google_stock\n", - "Date \n", - "2004-08-19 49.845802\n", - "2004-08-20 53.805050\n", - "2004-08-23 54.346527\n", - "2004-08-24 52.096165\n", - "2004-08-25 52.657513" - ] - }, - "execution_count": 150, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "google_stock.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can check that the column labels have been changed correctly by displaying the datadrames" - ] - }, - { - "cell_type": "code", - "execution_count": 151, - "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", - "
amazon_stock
Date
2000-01-0389.3750
2000-01-0481.9375
2000-01-0569.7500
2000-01-0665.5625
2000-01-0769.5625
\n", - "
" - ], - "text/plain": [ - " amazon_stock\n", - "Date \n", - "2000-01-03 89.3750\n", - "2000-01-04 81.9375\n", - "2000-01-05 69.7500\n", - "2000-01-06 65.5625\n", - "2000-01-07 69.5625" - ] - }, - "execution_count": 151, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We display the google_stock DataFrame\n", - "amazon_stock.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that we have unique column labels, we can join the individual DataFrames to the `all_stocks` DataFrame. For this we will use the `dataframe.join()` function. The function `dataframe1.join(dataframe2)` joins `dataframe1` with `dataframe2`. We will join each dataframe one by one to the `all_stocks` dataframe. Fill in the code below to join the dataframes, the first join has been made for you:" - ] - }, - { - "cell_type": "code", - "execution_count": 152, - "metadata": {}, - "outputs": [], - "source": [ - "# We join the Google stock to all_stocks\n", - "all_stocks = all_stocks.join(google_stock)\n", - "\n", - "# We join the Apple stock to all_stocks\n", - "all_stocks = all_stocks.join(apple_stock)\n", - "\n", - "# We join the Amazon stock to all_stocks\n", - "all_stocks = all_stocks.join(amazon_stock)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can check that the dataframes have been joined correctly by displaying the `all_stocks` dataframe" - ] - }, - { - "cell_type": "code", - "execution_count": 153, - "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", - "
google_stockapple_stockamazon_stock
2000-01-01NaNNaNNaN
2000-01-02NaNNaNNaN
2000-01-03NaN3.59661689.3750
2000-01-04NaN3.29338481.9375
2000-01-05NaN3.34157969.7500
\n", - "
" - ], - "text/plain": [ - " google_stock apple_stock amazon_stock\n", - "2000-01-01 NaN NaN NaN\n", - "2000-01-02 NaN NaN NaN\n", - "2000-01-03 NaN 3.596616 89.3750\n", - "2000-01-04 NaN 3.293384 81.9375\n", - "2000-01-05 NaN 3.341579 69.7500" - ] - }, - "execution_count": 153, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# We display the google_stock DataFrame\n", - "all_stocks.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# To Do\n", - "\n", - "Before we proceed to get some statistics on the stock data, let's first check that we don't have any *NaN* values. In the space below check if there are any *NaN* values in the `all_stocks` dataframe. If there are any, remove any rows that have *NaN* values:" - ] - }, - { - "cell_type": "code", - "execution_count": 154, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
google_stockapple_stockamazon_stock
2004-08-1949.8458021.97346038.630001
2004-08-2053.8050501.97924439.509998
2004-08-2354.3465271.99723639.450001
2004-08-2452.0961652.05314439.049999
2004-08-2552.6575132.12383140.299999
2004-08-2653.6063422.22729140.189999
2004-08-2752.7320292.20737139.900002
2004-08-3050.6754042.19259038.310001
2004-08-3150.8542402.21636738.139999
2004-09-0149.8010902.30440538.240002
2004-09-0250.4270212.29155239.180000
2004-09-0349.6818662.26392038.740002
2004-09-0750.4617962.29797938.509998
2004-09-0850.8194692.33589338.009998
2004-09-0950.8244362.29412238.070000
2004-09-1052.3246772.30504738.570000
2004-09-1353.4026682.28705440.009998
2004-09-1455.3847772.28062842.669998
2004-09-1555.6381262.26199342.209999
2004-09-1656.6167642.33589342.570000
2004-09-1758.3653912.38665942.959999
2004-09-2059.2943462.42328743.270000
2004-09-2158.5392572.44256643.290001
2004-09-2258.8075142.37252141.380001
2004-09-2360.0196302.39501341.830002
2004-09-2459.5278282.39629840.939999
2004-09-2758.7479022.41172139.930000
2004-09-2863.0201152.44449439.430000
2004-09-2965.1164782.48562140.840000
2004-09-3064.3812642.49011940.860001
............
2016-11-17771.229980108.598877756.400024
2016-11-18760.539978108.707527760.159973
2016-11-21769.200012110.357010780.000000
2016-11-22768.270020110.426147785.330017
2016-11-23760.989990109.863159780.119995
2016-11-25761.679993110.416275780.369995
2016-11-28768.239990110.198975766.770020
2016-11-29770.840027110.090332762.520020
2016-11-30758.039978109.161880750.570007
2016-12-01747.919983108.144531743.650024
2016-12-02750.500000108.549500740.340027
2016-12-05762.520020107.769203759.359985
2016-12-06759.109985108.598877764.719971
2016-12-07771.190002109.665604770.419983
2016-12-08776.419983110.742218767.330017
2016-12-09789.289978112.549728768.659973
2016-12-12789.270020111.907722760.119995
2016-12-13796.099976113.774490774.340027
2016-12-14797.070007113.774490768.820007
2016-12-15797.849976114.396751761.000000
2016-12-16790.799988114.544907757.770020
2016-12-19794.200012115.206673766.000000
2016-12-20796.419983115.512863771.219971
2016-12-21794.559998115.621513770.599976
2016-12-22791.260010114.860977766.340027
2016-12-23789.909973115.088142760.590027
2016-12-27791.549988115.819054771.400024
2016-12-28785.049988115.325203772.130005
2016-12-29782.789978115.295570765.150024
2016-12-30771.820007114.396751749.869995
\n", - "

3115 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " google_stock apple_stock amazon_stock\n", - "2004-08-19 49.845802 1.973460 38.630001\n", - "2004-08-20 53.805050 1.979244 39.509998\n", - "2004-08-23 54.346527 1.997236 39.450001\n", - "2004-08-24 52.096165 2.053144 39.049999\n", - "2004-08-25 52.657513 2.123831 40.299999\n", - "2004-08-26 53.606342 2.227291 40.189999\n", - "2004-08-27 52.732029 2.207371 39.900002\n", - "2004-08-30 50.675404 2.192590 38.310001\n", - "2004-08-31 50.854240 2.216367 38.139999\n", - "2004-09-01 49.801090 2.304405 38.240002\n", - "2004-09-02 50.427021 2.291552 39.180000\n", - "2004-09-03 49.681866 2.263920 38.740002\n", - "2004-09-07 50.461796 2.297979 38.509998\n", - "2004-09-08 50.819469 2.335893 38.009998\n", - "2004-09-09 50.824436 2.294122 38.070000\n", - "2004-09-10 52.324677 2.305047 38.570000\n", - "2004-09-13 53.402668 2.287054 40.009998\n", - "2004-09-14 55.384777 2.280628 42.669998\n", - "2004-09-15 55.638126 2.261993 42.209999\n", - "2004-09-16 56.616764 2.335893 42.570000\n", - "2004-09-17 58.365391 2.386659 42.959999\n", - "2004-09-20 59.294346 2.423287 43.270000\n", - "2004-09-21 58.539257 2.442566 43.290001\n", - "2004-09-22 58.807514 2.372521 41.380001\n", - "2004-09-23 60.019630 2.395013 41.830002\n", - "2004-09-24 59.527828 2.396298 40.939999\n", - "2004-09-27 58.747902 2.411721 39.930000\n", - "2004-09-28 63.020115 2.444494 39.430000\n", - "2004-09-29 65.116478 2.485621 40.840000\n", - "2004-09-30 64.381264 2.490119 40.860001\n", - "... ... ... ...\n", - "2016-11-17 771.229980 108.598877 756.400024\n", - "2016-11-18 760.539978 108.707527 760.159973\n", - "2016-11-21 769.200012 110.357010 780.000000\n", - "2016-11-22 768.270020 110.426147 785.330017\n", - "2016-11-23 760.989990 109.863159 780.119995\n", - "2016-11-25 761.679993 110.416275 780.369995\n", - "2016-11-28 768.239990 110.198975 766.770020\n", - "2016-11-29 770.840027 110.090332 762.520020\n", - "2016-11-30 758.039978 109.161880 750.570007\n", - "2016-12-01 747.919983 108.144531 743.650024\n", - "2016-12-02 750.500000 108.549500 740.340027\n", - "2016-12-05 762.520020 107.769203 759.359985\n", - "2016-12-06 759.109985 108.598877 764.719971\n", - "2016-12-07 771.190002 109.665604 770.419983\n", - "2016-12-08 776.419983 110.742218 767.330017\n", - "2016-12-09 789.289978 112.549728 768.659973\n", - "2016-12-12 789.270020 111.907722 760.119995\n", - "2016-12-13 796.099976 113.774490 774.340027\n", - "2016-12-14 797.070007 113.774490 768.820007\n", - "2016-12-15 797.849976 114.396751 761.000000\n", - "2016-12-16 790.799988 114.544907 757.770020\n", - "2016-12-19 794.200012 115.206673 766.000000\n", - "2016-12-20 796.419983 115.512863 771.219971\n", - "2016-12-21 794.559998 115.621513 770.599976\n", - "2016-12-22 791.260010 114.860977 766.340027\n", - "2016-12-23 789.909973 115.088142 760.590027\n", - "2016-12-27 791.549988 115.819054 771.400024\n", - "2016-12-28 785.049988 115.325203 772.130005\n", - "2016-12-29 782.789978 115.295570 765.150024\n", - "2016-12-30 771.820007 114.396751 749.869995\n", - "\n", - "[3115 rows x 3 columns]" - ] - }, - "execution_count": 154, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Check if there are any NaN values in the all_stocks dataframe\n", - "all_stocks.isnull()\n", - "\n", - "# Remove any rows that contain NaN values\n", - "all_stocks.dropna(axis=0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that you have eliminated any *NaN* values we can now calculate some basic statistics on the stock prices. Fill in the code below" - ] - }, - { - "cell_type": "code", - "execution_count": 155, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mean:\n", - " google_stock 347.420229\n", - "apple_stock 35.222976\n", - "amazon_stock 166.095436\n", - "dtype: float64\n", - "\n", - "median:\n", - " google_stock 286.397247\n", - "apple_stock 17.524017\n", - "amazon_stock 76.980003\n", - "dtype: float64\n", - "\n", - "std:\n", - " google_stock 187.671596\n", - "apple_stock 37.945557\n", - "amazon_stock 189.212345\n", - "dtype: float64\n", - "\n", - "corr:\n", - " google_stock apple_stock amazon_stock\n", - "google_stock 1.000000 0.900242 0.952444\n", - "apple_stock 0.900242 1.000000 0.906296\n", - "amazon_stock 0.952444 0.906296 1.000000\n" - ] - } - ], - "source": [ - "# Print the average stock price for each stock\n", - "print('mean:\\n ',all_stocks.mean(axis=0))\n", - "print()\n", - "\n", - "# Print the median stock price for each stock\n", - "print('median:\\n ', all_stocks.median())\n", - "print()\n", - "# Print the standard deviation of the stock price for each stock \n", - "print('std:\\n ', all_stocks.std())\n", - "print()\n", - "# Print the correlation between stocks\n", - "print('corr:\\n', all_stocks.corr())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will now look at how we can compute some rolling statistics, also known as moving statistics. We can calculate for example the rolling mean (moving average) of the Google stock price by using the Pandas `dataframe.rolling().mean()` method. The `dataframe.rolling(N).mean()` calculates the rolling mean over an `N`-day window. In other words, we can take a look at the average stock price every `N` days using the above method. Fill in the code below to calculate the average stock price every 150 days for Google stock" - ] - }, - { - "cell_type": "code", - "execution_count": 179, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2000-01-01 NaN\n", - "2000-01-02 NaN\n", - "2000-01-03 NaN\n", - "2000-01-04 NaN\n", - "2000-01-05 80.354167\n", - "2000-01-06 72.416667\n", - "2000-01-07 68.291667\n", - "2000-01-08 NaN\n", - "2000-01-09 NaN\n", - "2000-01-10 NaN\n", - "2000-01-11 NaN\n", - "2000-01-12 66.500000\n", - "2000-01-13 65.416667\n", - "2000-01-14 64.583333\n", - "2000-01-15 NaN\n", - "2000-01-16 NaN\n", - "2000-01-17 NaN\n", - "2000-01-18 NaN\n", - "2000-01-19 NaN\n", - "2000-01-20 65.229167\n", - "2000-01-21 64.541667\n", - "2000-01-22 NaN\n", - "2000-01-23 NaN\n", - "2000-01-24 NaN\n", - "2000-01-25 NaN\n", - "2000-01-26 68.062500\n", - "2000-01-27 67.000000\n", - "2000-01-28 64.479167\n", - "2000-01-29 NaN\n", - "2000-01-30 NaN\n", - " ... \n", - "2016-12-02 744.853353\n", - "2016-12-03 NaN\n", - "2016-12-04 NaN\n", - "2016-12-05 NaN\n", - "2016-12-06 NaN\n", - "2016-12-07 764.833313\n", - "2016-12-08 767.489990\n", - "2016-12-09 768.803324\n", - "2016-12-10 NaN\n", - "2016-12-11 NaN\n", - "2016-12-12 NaN\n", - "2016-12-13 NaN\n", - "2016-12-14 767.760010\n", - "2016-12-15 768.053345\n", - "2016-12-16 762.530009\n", - "2016-12-17 NaN\n", - "2016-12-18 NaN\n", - "2016-12-19 NaN\n", - "2016-12-20 NaN\n", - "2016-12-21 769.273316\n", - "2016-12-22 769.386658\n", - "2016-12-23 765.843343\n", - "2016-12-24 NaN\n", - "2016-12-25 NaN\n", - "2016-12-26 NaN\n", - "2016-12-27 NaN\n", - "2016-12-28 NaN\n", - "2016-12-29 769.560018\n", - "2016-12-30 762.383341\n", - "2016-12-31 NaN\n", - "Freq: D, Name: amazon_stock, Length: 6210, dtype: float64\n" - ] - } - ], - "source": [ - "# We compute the rolling mean using a 3-Day window for stock\n", - "rollingMean = all_stocks['amazon_stock'].rolling(3).mean()\n", - "print(rollingMean)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can also visualize the rolling mean by plotting the data in our dataframe. In the following lessons you will learn how to use **Matplotlib** to visualize data. For now I will just import matplotlib and plot the Google stock data on top of the rolling mean. You can play around by changing the rolling mean window and see how the plot changes. " - ] - }, - { - "cell_type": "code", - "execution_count": 180, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# this allows plots to be rendered in the notebook\n", - "%matplotlib inline \n", - "\n", - "# We import matplotlib into Python\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "# We plot the Amazon stock data\n", - "plt.plot(all_stocks['amazon_stock'])\n", - "\n", - "# We plot the rolling mean ontop of our Amazon stock data\n", - "plt.plot(rollingMean)\n", - "plt.legend(['Amazon Stock Price', 'Rolling Mean'])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [default]", - "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.6.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} +{"cells":[{"cell_type":"markdown","metadata":{},"source":["# Statistics from Stock Data\n","\n","In this lab we will load stock data into a Pandas Dataframe and calculate some statistics on it. We will be working with stock data from Google, Apple, and Amazon. All the stock data was downloaded from yahoo finance in CSV format. In your workspace you should have a file named GOOG.csv containing the Google stock data, a file named AAPL.csv containing the Apple stock data, and a file named AMZN.csv containing the Amazon stock data. (You can see the workspace folder by clicking on the Jupyter logo in the upper left corner of the workspace.) All the files contain 7 columns of data:\n","\n","**Date Open High Low Close Adj_Close Volume**\n","\n","We will start by reading in any of the above CSV files into a DataFrame and see what the data looks like."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# We import pandas into Python\n","import pandas as pd\n","\n","# We read in a stock data data file into a data frame and see what it looks like\n","df = pd.read_csv('./GOOG.csv')\n","\n","# We display the first 5 rows of the DataFrame\n","df.head()"]},{"cell_type":"markdown","metadata":{},"source":["We clearly see that the Dataframe is has automatically labeled the row indices using integers and has labeled the columns of the DataFrame using the names of the columns in the CSV files.\n","\n","# To Do\n","\n","You will now load the stock data from Google, Apple, and Amazon into separte DataFrames. However, for each stock data you will only be interested in loading the `Date` and `Adj Close` columns into the Dataframe. In addtion, you want to use the `Date` column as your row index. Finally, you want the DataFrame to recognize the dates as actual dates (year/month/day) and not as strings. For each stock, you can accomplish all theses things in just one line of code by using the appropiate keywords in the `pd.read_csv()` function. Here are a few hints:\n","\n","* Use the `index_col` keyword to indicate which column you want to use as an index. For example `index_col = ['Open']`\n","\n","* Set the `parse_dates` keyword equal to `True` to convert the Dates into real dates of the form year/month/day\n","\n","* Use the `usecols` keyword to select which columns you want to load into the DataFrame. For example `usecols = ['Open', 'High']`\n","\n","Fill in the code below:"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# We load the Google stock data into a DataFrame\n","google_stock = pd.read_csv('./GOOG.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])\n","\n","# We load the Apple stock data into a DataFrame\n","apple_stock = pd.read_csv('./AAPL.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])\n","\n","# We load the Amazon stock data into a DataFrame\n","amazon_stock = pd.read_csv('./AMZN.csv', index_col=['Date'], parse_dates=True, usecols=['Date', 'Adj Close'])"]},{"cell_type":"markdown","metadata":{},"source":["You can check that you have loaded the data correctly by displaying the head of the DataFrames."]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# We display the google_stock DataFrame\n","google_stock.head()\n"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["amazon_stock.head(3)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["apple_stock.head(3)"]},{"cell_type":"markdown","metadata":{},"source":["You will now join the three DataFrames above to create a single new DataFrame that contains all the `Adj Close` for all the stocks. Let's start by creating an empty DataFrame that has as row indices calendar days between `2000-01-01` and `2016-12-31`. We will use the `pd.date_range()` function to create the calendar dates first and then we will create a DataFrame that uses those dates as row indices:"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# We create calendar dates between '2000-01-01' and '2016-12-31'\n","dates = pd.date_range('2000-01-01', '2016-12-31')\n","\n","# We create and empty DataFrame that uses the above dates as indices\n","all_stocks = pd.DataFrame(index = dates)"]},{"cell_type":"markdown","metadata":{},"source":["# To Do\n","\n","You will now join the the individual DataFrames, `google_stock`, `apple_stock`, and `amazon_stock`, to the `all_stocks` DataFrame. However, before you do this, it is necessary that you change the name of the columns in each of the three dataframes. This is because the column labels in the `all_stocks` dataframe must be unique. Since all the columns in the individual dataframes have the same name, `Adj Close`, we must change them to the stock name before joining them. In the space below change the column label `Adj Close` of each individual dataframe to the name of the corresponding stock. You can do this by using the `pd.DataFrame.rename()` function. "]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Change the Adj Close column label to Google\n","google_stock.rename(columns={'Adj Close': 'google_stock'}, inplace=True)\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Change the Adj Close column label to Amazon\n","amazon_stock.rename(columns={'Adj Close': 'amazon_stock'}, inplace=True)\n"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["\n","\n","# Change the Adj Close column label to Apple\n","apple_stock.rename(columns={'Adj Close': 'apple_stock'}, inplace=True)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["google_stock.head()"]},{"cell_type":"markdown","metadata":{},"source":["You can check that the column labels have been changed correctly by displaying the datadrames"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# We display the google_stock DataFrame\n","amazon_stock.head()"]},{"cell_type":"markdown","metadata":{},"source":["Now that we have unique column labels, we can join the individual DataFrames to the `all_stocks` DataFrame. For this we will use the `dataframe.join()` function. The function `dataframe1.join(dataframe2)` joins `dataframe1` with `dataframe2`. We will join each dataframe one by one to the `all_stocks` dataframe. Fill in the code below to join the dataframes, the first join has been made for you:"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# We join the Google stock to all_stocks\n","all_stocks = all_stocks.join(google_stock)\n","\n","# We join the Apple stock to all_stocks\n","all_stocks = all_stocks.join(apple_stock)\n","\n","# We join the Amazon stock to all_stocks\n","all_stocks = all_stocks.join(amazon_stock)"]},{"cell_type":"markdown","metadata":{},"source":["You can check that the dataframes have been joined correctly by displaying the `all_stocks` dataframe"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# We display the google_stock DataFrame\n","all_stocks.head()"]},{"cell_type":"markdown","metadata":{},"source":["# To Do\n","\n","Before we proceed to get some statistics on the stock data, let's first check that we don't have any *NaN* values. In the space below check if there are any *NaN* values in the `all_stocks` dataframe. If there are any, remove any rows that have *NaN* values:"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Check if there are any NaN values in the all_stocks dataframe\n","all_stocks.isnull()\n","\n","# Remove any rows that contain NaN values\n","all_stocks.dropna(axis=0)"]},{"cell_type":"markdown","metadata":{},"source":["Now that you have eliminated any *NaN* values we can now calculate some basic statistics on the stock prices. Fill in the code below"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Print the average stock price for each stock\n","print('mean:\\n ',all_stocks.mean(axis=0))\n","print()\n","\n","# Print the median stock price for each stock\n","print('median:\\n ', all_stocks.median())\n","print()\n","# Print the standard deviation of the stock price for each stock \n","print('std:\\n ', all_stocks.std())\n","print()\n","# Print the correlation between stocks\n","print('corr:\\n', all_stocks.corr())"]},{"cell_type":"markdown","metadata":{},"source":["We will now look at how we can compute some rolling statistics, also known as moving statistics. We can calculate for example the rolling mean (moving average) of the Google stock price by using the Pandas `dataframe.rolling().mean()` method. The `dataframe.rolling(N).mean()` calculates the rolling mean over an `N`-day window. In other words, we can take a look at the average stock price every `N` days using the above method. Fill in the code below to calculate the average stock price every 150 days for Google stock"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# We compute the rolling mean using a 3-Day window for stock\n","rollingMean = all_stocks['amazon_stock'].rolling(3).mean()\n","print(rollingMean)"]},{"cell_type":"markdown","metadata":{},"source":["We can also visualize the rolling mean by plotting the data in our dataframe. In the following lessons you will learn how to use **Matplotlib** to visualize data. For now I will just import matplotlib and plot the Google stock data on top of the rolling mean. You can play around by changing the rolling mean window and see how the plot changes. "]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# this allows plots to be rendered in the notebook\n","%matplotlib inline \n","\n","# We import matplotlib into Python\n","import matplotlib.pyplot as plt\n","\n","\n","# We plot the Amazon stock data\n","plt.plot(all_stocks['amazon_stock'])\n","\n","# We plot the rolling mean ontop of our Amazon stock data\n","plt.plot(rollingMean)\n","plt.legend(['Amazon Stock Price', 'Rolling Mean'])\n","plt.show()"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]}],"metadata":{"kernelspec":{"display_name":"Python [default]","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.6.3"}},"nbformat":4,"nbformat_minor":2} \ No newline at end of file diff --git a/Pandas/output_28_0.png b/Pandas/output_28_0.png index 3b70506532ae05043f3c921d2f485469895f2ce1..b5d4aec6a98a8c3a951179062a4d04c3c63a8ef9 100644 GIT binary patch literal 15425 zcmZX5Wmr^E*Y?n%gru}cw{(Z7#8A>9rAQ9l9g->`-67o_(jc8fcX!v&F?wN#HD2;_liU|UNuw-T4tAIcV?!f1JbX4H4o0!ci2qc0o z`~Iz(>)hd@izmT{$F@_buB`trDFz7%A>=3-o42?h-x3hK{ZKBN&-f!EbB0kYGeir- zlKD+M@->){Fb5s|^;@Ce(<69@<`PjXu)B3W>2PFp%sx8LM3;U0LFTG6=X?tYCnD83$iEn8df6Xr`qE1kdR+l z!0$B;A8s!gYNj@Se8`9h33uQs(`8WH6JU%Cuk!Z(m;@EiLWG zEGaA|TuJpRQ^r?n! z4#bZ)dt43VVqjvv77|Ljz1Zirn8^1Wrx10IX*_QEq{wKuczYI1RqyszZYklKQ_*x4 z)dS-^p402rajw>CAe4l=i7$dLIm{0Ut~0eo8QD(dbKg#E z;JNx@C!WJV(bAIjYQX`=X>a25O!;T|WWKPip=5j#lD?&84+O1pLj*RR>Q}(zlWkfO z@fj3Bw)0kXF9-=gsHqXWefw5ERVa3FP@d9#hx#=Q4PXkB*-B%Od?Ht%ezUvX09)P1 zMrSL1*VRCg8+j$A9_u=MA|h1ZvN8^*{VC&%y~)9J@$}#Cg7F9myMXa#|Jc#6eX7m2 zTkk$Un2jFKQ$i{?g;H9#+?XWsm`lpbhu#TqXw_L$jE;^T%-0=fZmJimFoqv8w)r9PSWKXUf;-w_P;sTNUunb0_)XS2zn6*!Tk&%*`rdQXHYFrep2 zJ6g5Xe4O~>J$?>BG=q}K!AwQd-BBZ}PIWKE%#-nsnqZ1zw>vbTTFcqL;S|C!(p5*L{N(E zEHyVa&eAfJcXxMld0yK}g^_llQF*pKTrES(KX>fRRxuPg~-%rv=i|Ni}(T)?(1)p{&j_F%a+9gB?5 zutH0~X^(&}dFX*;vp?2oYcR3tte?g6W-}g-`u+Ej97&-RdxfIV_ZhzduQRVD;rfaW z0;0nB_I&q9V!2qGn_0aOxebedK_Z@A4-^s_>NwqvkB7H2o`=&DPC+9qJimT(44CSy z4GHHBWQz6Mw{KcC7KHw2IH(zbYXMKcNUR9tDMfZ(>>$u9r47ch zeY!rZTYkxJP2LK>Wl_zQKb472N&EiSdGW6GBjC?KFpHeDAx-2f(0Au%5Q-LTvJw=sC*n4E<*G#6RD@Tq5d!}+^4<828M3dnUcMc~jZ?VY*+EzP) z3zV}^i!@4@PsCJIRSQ&dFhQz$icTCsS7mTf3 zXT6B%r6?tZ3e4RFYP0Ys5^yl2Ck%FX7Xkrj5fBhiZodfz!H*x|5i>Jd{V`1MTwMhK zv!T3VVfhJw79uV=`Cx=Nymx@3_287`aSyLnj#%vBT=fcPsz5a_|5F{itgP&jgiY1# zOs!RNN=Rnsn@!AfW?0M>ihIsP6}Z3(Tu=fo*ab6*=cr-jOz7lHSm#X0=fp%rPE98) z8x=<|mJaa=Dv$^sHSDvuJY3Er9vcC6K0jJac0Qa_uC>&@Is@>h!u9ma71rzxY@6F` z1)m+z!4Gv8jDq&|<0L18+nSZ>Xk@^FH0p7it>as))U?l+hTuysx zLD&>vAby`vts@x61?>R?pMKbLL#OLKi+5!oeJ| zA(90Zz8qKg?dYy`rtwN3H=*vlIM7`Fy~x|L#RHkdQAvoN5@b;Z^58oqBnN2*KI=mCy)7~<5^+hvma)8k}9A9@_R8DkPbG=W#wDsS8$tS(a>)4xI5x;VL4DAjh zn*~q|fcm5Go>Da+mAvFT*wdStC{+LH2GeCTR?Lew9*C=7ZX=X*jXzx;&Pj9Nn4KH6 zf$ND*O?vK1R~}5a2qR;hqX1X1gp&(KIRti${C;OXk^ce+oxv1ASk$~Czzg!y-23%t zd~SF1%oiJYc_CAdSEEOcLL@w9xIkXX_P9D)aGtj!K5Tth@;G+#**e=CFdxqiYxIBP zYtwQQ^h8d85HN}m4eD4GicE7|!vH)P3;-Jm=a&FsFM#dQNQJ(lrw{7wl_{h8`XOX( zEn-ntqzVGMPzXL%#?~*6_iRCFI~KdVS?WomYHiuNVWe! zwQ5`bwGWTdZQ}*V`+60P&w8OZS0P!z?TmIPi8l*~brkrHQBQb<#U!)y!OUC0UVngu zezO`(C1AS(`c!L4&B+-F1QzV1182L@3yAJSejCa>rF0V@1D@|sN2Gh-V%Rnd3OQ`a z!>`wIiZxjLQL(-NaC&~coIaW*jZaGYqhmD#KwZnFrbJ+QkUj#~1c%?*h{3OofbTsU zebJj`Y9T(mIW}<>ucwi=V`01795Zo@ytkQ-M+<_PnVIO%o~=(5s2;I9YL@79HD4|L zoVCoA48-j0?yj_6Y(PA|8Wuk8{K_?&@fPXIkQM;^Oqb&&AmuS@6!$9dFFN*lo$pQl zB;htGcRtjatAT9mw*Y3DDl<^3G8qc_@#9Nh6x~s~q{&dy2YLDDK)SS?uN^YlC;(D4 zg6(=3zxz1_N5J(qrS0Hp0+cnmjzQlF8b>PnaV6<$GHzTd9mvX8M~gQ*SrM*)M?7Av zwA2f;49rf)9#sJ;rn9s2jbR%|o<6zecXFYxgG`s0Yn zn3$NPiRcxQeWiZio+=hSgrGMnN)>&>TS~|LlFI|{P{5J41u`H|kTF=LaD}XC0rU=;0vilXO z7j^H9W&xi1tLF@$UYs76mU#Gj@&0*=scS3k{@FP>$^ab&n2LbiT0mogG`gLYXTukc zpX5WkQ5SqzDcstR8U~)M^w>L?M?6M{UUtZu@ubalA^#~L1`{~_y&rBXOom7Svb#nZ zn*F8g$75mNdTHa)lbHcB8zSViHJ;tVpDqxShywEb*u)*-EZT&ofb7` zqtaBPmBwY<>pY;<9uqYFGZuzX^Y7-y0MMn|uF5UQNj zw>1S`n>)SJE*A5i7U96#Y3`jQEmT5RKCi4MG>CP$G z83{YVS)L4LtkD(8iO0Ht$&tv=`y;V&5<^zr&9rw4+spT zMpDE0SMOcl+{k`LFXP*ZMmZO`L@1l5qFby(Oulu+UXDD{42+;~87q-@{k_=-LGl8q z2nGg5ZwBq_s|X)g*FOXSCl;v@UQ)y`cdiptlN?Q0v5SD7X0C?ADsR54RYsjo3BbMH z4Ua5 zHWO)TD{2wTF=SN1i-Bpk6NO zM1%G)Q6MaFQr14z*MGp)=fcaA?cSy+DoC%N>f-mZcw4qu+ljeIf0*vPu+?^0pQ_g% z$rBEIuY(?X2c3e?ijygYLTL4ZK2_@K6=`CeUi}b}11j_omR|{RvSi~#EpV?-X-@D- zBeVU4&Q1n*5blP}#Sf7IReoUlD4tw+*Zo3qf!cMTG@EAc=B-yCg}?qYJWbEwVkTw1 zRZr7m%%~&ks`@JZ+R0MMzFh5@yB=$Kk^(Y{tCIisf9FAYs@&#Xlokb9tYd5iQW9xA zG;FFfc`OKvP0Ytnnn5OLNxLcfs)WiR&yAObJW{^s{B0UfsyrF`6p4Pk3&y!5x-v+- z=P*0kUQ}#$sVVRhXM{<-nHEsFy zmG0ljjBttnyx`v{ zUsfx+VeMdwh9r*|MyQ01yz46N^w~rht|Wo4x?uVG-q=c3P9vkS-AJ7=+qbaD%*%9< z^%6UMi>GJBHTHbasGgay;&SO!N0I|@@Gel3aS3?M=ke%U7`$R0dmVfV+Cl zUk5M_R}R-BHqTD;@)*8uPZ^=U$;BEm{b3d6Epk#d)j&Cd9D){vAXhzA<44ym@+U~Q z!0Mh1-Sc(ccicL`YV%`D4;U(AjBKY2hq>#l(cK#e3r^aKT9Q2=v7 zTtJZLjZ#24;>kS*wM?=5AOcea+ZO^cQPgHXsWo?Q)X!tP7}`ARB5b4GYS;iZ3;olJ zLGiq;xKfF5fYeLj6~;A~spc&cuQro9W`0JEn2Befk%Xd8D!^jvYn9%_VE~cu$a6u? zz+JiE?{#IVvuO0tLB+n|B8^WuKq;9l#rxAZqYlK`#-Ourw(@*C+5D^-z1K8xcpLmV zLxow9i7-AUhSoF+_b-GlMW`o}t*5V=4BDGqOu2uomj1Pk50k?>jHO^%bWP{fY_yi!_F z0gpb*1IgI=!VPA4`4Qx8TWyqFB{a&vydQhRVU}m&?`IBXqB5j9`E^ReDaUkyZi~KS zm92-ofO>#1Oll5<@%8l1qPn|gSc{*KjJ*_5x^M%mK1X~ej zAH(JZu4GICX|r+;6yv;q53S8=t99nuS(B1~dQ(*zryuRs%^1Epqy>OpsFfXy>l7E6 zstGeF7%@vQ%S(IRQi1`78l-KyaVOvWFWl(Kd-zU6H_--bpM$>Lmvrv$(eA)-qMEj0 ziPKvKsFW`xLk4=?3Q^b1lbNaEj(wCE5*#paQo`kDb;Yuw)(HTF*0|C*QBnCqBnD0e|c(KJR`#RBn-gx$&*X4lTw0kq83%KKc>hV}U0q6j5 zo4+=v3_CVhj#r9_G~0(WX;-4d<5)Uw7cRg4oqpdxYl(fmDD43w8b+P^^UA$puW#=2 z)$Q>=@s<6}-r|+vS6sPevK4)epU6*dxTZ+4Dz}e-2&!%T~l% z>z2KmmoTL+ejbX>y}@&t^^<3x18Jg;v~8YL-;g!>*Q~yd_o8u$B`uUNZEB|-8;|c| zF6aL-VVJ7_IC=zH>LxxM~j_ly$x?$J-%&Y1i(&EQYe^@9h_ zCO5K&R1?0;@7_?X<2zem_w5GD#fCXJ|w zb-{)Eo?@zZGsXuw%M#~ACfbb1rA+^IOZ0ypex;xP*UZXiaG(Y==dvu|z9IW_qcIM} zOUd$i?wg#61gAY?HzzG-F)DOh!r(A{bUVFyciPzP*7?rJ7>CfC&scEr$9O3YFN4gM ztfyN}*ZB9DB52jpM3SDS+ou~d@h60Tt0GPSOX+C=6JBdDvHxlxZ;m1yU%dJ*oeIJ1 z^Bgtr6Q^K8WK~?cxZz1R@QoU;WV3pjN~6?qvdiGK{w8s3@iAktHoBcC40d`@WD=W2 zE&kj>6&RCe5uLgeqEYpo>5?6&dCLn9879h9^EUKq2zY+0^cTm>WyI*14NiXqm#Bje zHNZn^;G35NUST()-M8q1u>rVCV8}~zpI;6*aH&UjHglpE?hmN$DTADypC@wfmf+TcrC|v5>a;3w;2i8X0yf{g;`Dd(J~FX9bU=!sF#DT|6Mm z8VwIKRv2rI@ZIA068on7R{QHqP*Ss)p!8o!rBv>L`ur@K5USvuT#5qzp-hi11M=e!i&nq8yM^v}q_zk4#Ilc>fM|LAFyf z#bI93Q8V>I!oaX#>ekzk#I`Qd67&X|kY)o2O9q8CQ}+Fs)TI-b*N08U4~V|8;Zh*v z6k%`m%SE#p7m@p2yxQZXKvfpcZ~gHz_V@hL%p8c^F)B77GGC6+O#{$lUd)`)#Kv9! zE_1*&!)0D-I($Go!g;IY>nHHz{=?Gcl1lBZD5hX52_~~fKC9nS{vroj9NGAt@77Ir zAF}%Z6L4LfC*nKp{o-JSWOKrKLJerHt_->nQI~_q`Wer2oIB~e)R^1!`(ygJk7Fp` zfLv}R8YPu}u)1(P2OicimmV6lnTgx#DR0%OJR3KKkBULR&SGe$;UKhpZft!YpXKQH zD&Pdn7aZ;1$gfJm0+8vLz5smu$v7NTd`Iqw8z`dJ91~ct{NU?ksY(_At$#OcE!Hkm zzt$f++^^kbvS^VU>uG#s0%gaPo<>}Ho&PEN4Cj}w_Lyyam;*my@!uGGzU0m_J)C2d zLWj~osbqJ$O?Mp+g)VQ(d9xDjR%5cex*k3E`LYh zFC<+llHWN5yYYhL`mr*iUu;uxbASN)#Vzca>}nZp#~w}AYBThL0yXPW&vE%sr}}Hw zGNLWP1}R1)hvj}b}YOB}@T*O{^B;(lYo`t=lFr%`e^g%HB8i~;*w zdA>a8*X_pRlxhC5yi%f^U8$$x^kG$5BpJIihx#DJyc~SPVjOBDgU#9PA)C|h0Rmt0 zEd+=5ZCXCKDZ;vUaL!QO*L|EQL}fUh5NFyhMRW*#f7;T1Nn)~p6%=!Jv3l2V%*AGc z%7Fg63H-TZ>hQ>_l0s3ee7P&+04`tI(nB^?W-H_*#(SH>{BWU~_5}Y+#5+~c7glo} zzovd)-~ACHdxp*0rFSLP{~&5j_wEkqxs*0!B54p_`&~>>Lf8@|9eX6 zu&ql2%FlRPmx%crlVML4rXioX=}z;BowB^sU)fR|0VhJ@_cds~RYH#qJ9>vkpzAUx zzDXSDrriMIRl_T%El=N1S4?P%X{$8*$U!GoMXbX<&CJT3-F7>zH%+MzuL|I88;a-es#TicV1XgF>XG>58h-&mOg<=;=4Fh>7w zCRr8oQEb+NsWwSfiL^4nxK@!vm>$w+Nm&B1~#?xYdM;vRigjZG(Pg#P#0xKCn0 z)9l1@UA-_3OBGBQ#I=RBDK@~BsnB?{G|IPp2)7XP^KHXrYJB3FTj>ySasc;r3~E&JrDXu#|^OZ|RNU5M`#IJ__ThD6R;XoP^)?uk~KuIjuFrJ>QFqZ!x!?Ddr z_R^?Mt-U{eAFQK>(Nd{Tp_H5b;`6z3w9$4DVJD)JF^*JTiqCL!WyP`aqKR_?olZx;nf71WJp4lPzJjeU>}pmYrgb`Qg?c>q{Sdz8X?Tp%78RQGyawy5#G|z9 z*4CU`?f!hGP~EbtKS9eAM-5!X8X#V`LSF;q=!f9EG-L#zr!on&bkcjhm}d+M`!|Kj>^I#BI8gG=1=vBYDR zHvOu=!ve!RvG%96i&mo$GNf+PI7r8Iw7uy&nS76HVRO;?8-t?6xI}yebb38Z9Uz)B z87=2(W0{MBk#MhEQhFLZutN>k{=6VwbS})2YZ(}V`}r0z^gUi2_s`e1Bm%Q_FzuK(jM`s)p$^ zsjD;9$TJa^#mwc#xOZz&7RKBHN9M1^JGDwdSc7tr=PN5KC0MO7Uc#9(SMBA#Cdo0ZxrqLF+BY~@vBNS-$5Xa&w2>+2wXc~W z+ec~!SF*?LP^dbJKnkP^*=RQKjx;~!hbp*>j*hM`5_gSs&-087WMLanP#b<=d5_q> z_grH$W9js!R9sCj+`Bg3HkZO^FE~rf=Y#;M<^Jb-LE?-NrTy_h0W02yoJEEvI2N@9 zEy%27oIRGO^_jnCDFMBCNwP&ravY1MVmQ#B)z=gz{Zi0}YCavu|z7F;(VSC?-uzcOun$(2xA zWXvg+`jwtr18>&?WIb6aCUp#%L3MvX&w|;m zI0rJkjIctqHhYG)jac3`I<{D~soEjlzD8rzNF?1)82?jaJXgU{ff+T|)t5kxC^`6M$rWoU6te7pQEd*S;H&@y9RDo5 zD3M{cz&{`!OA5lq@xjdqq-oJS)v()I3MeH_n)Xt0!o6hPHeV$;m2_@5_8_F5J8^`7MzZ75=Ck>aD!1N%J6?-B34FiIu~t1j+=UX0KbkbDLV#a!-AM<8>c!NRmI zjPA{!VuFk(VU@VQTCf*j@(SKUvvH#*gL8;^IL8ls9feAHI%?8_36g*Uw!vV(!7)Rg zgk;q4yM})CT(CdxvTM0VmsVV;%*3m$djh*{9c3;T620eWrJ{$O{qMf^CZ>v zS6pLUfyS+a#_cDccKMvC#jV&2FZ(+`b+7Vy(mNOS#26cz#2bd`Z=Ma0y5U#y(bUyG>`G`ISt* zM#j1YxtQEb_9{id_Pd)?++p{h%8qyMHb59abLrXD?{RsphG3*VQ-Nfw_$;Oca>b!0 zsB~ocAx=Y&XpBwLZSFgsg%kIdeZ|y1lbhl9W87AQ$&aG^Y5(I*79f!W`-)cJ;Yw8jF1 zg{Sqegwq_`ec9sPE(3X#Ix3l(PahTlTOEz@<|TR@dk)Ef z^w(J2TSU?(9BSpfFIQDf3r-c}tP}Mj?3oWUcf-YNaH7vem}o}~bT-e~nv7E4r!3>& z@A7Mf=h_Op36c1cDU|ZdE}yw2PNvhuhV*Q0OVi@a)9KPj72LYrkw=rduuzbhsPyX5k%(jYFaXh6=B|bsKEG-gTLv z;0vZ<+TQ5Z&s$1vj!Eqx!xJs}-gEX=39IW1ALsa}9}h)av9yuEBpeGwS#ke9nyJRE zpQ}tFy~6P#>1XMu`UBIsI(1>q&R=BDD<{J{- z6GFEZ?^Z8xCm#Q@H!Plded-m8*FR|W@ue9;pL!cpq!k99#H2LyaB59;A?4WE=^%p@ zHx^jC9a+1>ttQ%35Uv@~uI>qjLOGTlM2*CAi5pYZdq=zvY&A9qcC_)d12mZ~^!*qhK_98v;i3egU{8f{yKXB;M9V%;zgndMBHXb*UL+O*zx==^I%PVadaX4a-@Yt- ziN{S7^h5BORIYwilX+hB!>4In+?VoQq*!HrrZE@=z7GlC?X$4;PHTVXc)pw~((@ae zGFu>;@>(yXJ2ddS@F{bMK8>&bniUIUtJMRRK4HDU^$6{~ zkjlTogL+ZP3H8-3x8`a0=#vX(-MF{g0G&6XWfS`ogR$&4_3HsBw+55;CvuDa3fg5i z7Ddw8WjF)1}4kBLirH%}nO{08vhNNFZDzK{(=-!y&5Y8!p1>B*_RE*3WLu`EKe@N6zX`+tW=cJGPY?t+SWc<0-HTYZL1Ss zBTB&}PE*aEH3lAg;^!}@2@Bo$W@pG*eVV!T2KQl$22(73*WuVKC)-pF+r(f^a|yFw z`?I#e9dB!g!f9Ci$Bw6)cAR_e*i4}Y;^WTKFRv<{6qb#*BWc|ioy6lZn8}6he+e42 zDC{pm$3!ZZZeF$eJlo8zZMIzE6N2Df+y+SsV%v2jk4{wo6fmVoYH3k?9sWzgAi+

r6oir56U{tDo?M{?GU#y!}3@-`inNzkm! zqwST2#}`i14m=PoVqWI!!Yx>yP?;*72%<;-i!X5R?>Vl%3idAD1q0SvXENAvJ z<;RST*p!=TGcT`HC1vwenfRBg1h*PhuEq}h_(Sqt4}+qG8+_1WArr8sOk1Hoq2%tp zHp{oi;J?OC2}G@|iG zJI{(ap7e2EZ(B;$@_NWuskcaD@Fv$by zQuoaZNS5%+nX4nYDHZ%Em6_Ws=F8$Fh25LdVYB;Zc;&rO-ik>HzJVR~enHkFNmo@)!N~^i#g@IP81)?q%|y#ipP!X6|LH z+9fzmn6*f&!rZL9hT=UA6Ln;@T*3yW)>^v2m<@`H!qWSYenYjMN}#pIY3{spdD&pt zf;s@`63&@mYjbUTE zwP*i0`=Y!DS_3xx*9xZk<{;2}>jPBkiGF$#rmqmDJp!&QO6oj}GN408wv`t{m+u92 zAHE+uXk?GE%nPKtCmC!%P^C6p(0Qsn3>i4svZ+6cz(y(f#uXc$S`CIa5~YSnFkjPlA5uGp5|AZL6KBOynBj-0Pik~B?d zSOWe{thY_95gYW*=Tu9h4>r(8!WeKuI-R-rs+BQ*yYekWR2H(R23f4ut+%(Q1-3n2 zqTC|Cy3*_Vk18M;lOoZIonI1D_&eqd;T92=lMi&7nCV{dxtG-FFb8>OwcCe`$9Qo(I}|q*tuvaN)609ASsCwA!lx~<5In^vC0r)s z$~~G^JSrV8ii(M>56Y{2Fc0X6k}>yB%^D$V1VC$)daTMojLPZ1mlI4wH-Cc*3}RIp z!yey-Zi1P3-!j!mGu3D_5k^A{kV4NJV^xrTaEXHp7;`2_ji>-U%0e;-!%g?sRzomTyHH z(6s($#meZGZ-qhkVWkdvige(epI7%Ib+@C;i>*BDkMjwo&&iR#{bUxezvQR9Cb}+X zjEJwW795#PV8=oxSUt7Cy7wzG65}pM-LVaWsZg4shN7lHYpA%(iSse8LCLtH8 zF7FcrNYg3j!eJLzi0PX;N0FuFuxO|^-zG9VvmeKn<_(hTNjmCnk!uqvsHkb@-W;VE z?cNXc3OnD24Hm_+*!v6-!m<*t3*$iG(A%%9*YaksP0t*}DYfH>15rGhXSDw4DSBQ` zwN9DOe-GQ^b6+15CDnSSHljntT`Cz)(wh70aU@Wky`l-QtB3edn88i+hghnd7z|h9 zmwR+QMcBVGV{Y63+Acw4f z@1G+QnU~;r^qp3M4t=-723C{0W2GWDq?y#8<=adU6g_EChh=v9@KHf^_Bv@~dMID^zvkUUFj z;HCKk(h#rKsfMH}p}+Ybd`fC4H3E7d6u6l&{ks_jH090cFbDJyb+C4*I9%)1Kl_*V zpQLEAh{w+;0rrACL`?}T2*lqZ%GFFg02Ax+>i`!tbZ06)Zs@iYHl1uiKCM?ea+i-@ zyO7}q?VAh$O^qLEni0jg<{Ilj3J!<+pA92UkADLmG=fvUIoBigs*rJjVOor8BVF9d zfj2_a)JXi3FO#p*3rY^|QnH%UZmM06z+dq{q^#ax$#CWlY`6=V#YaLl|0iDmT`qhA zO>d}A>S4j0#=0Nso-~(H?pAjLc7dqD0{{N~L$QDDRFY3f^nal3e-G*^!Kq+yQ6;T+ TFDijogF&(%6yKLh8h-nKWpBPQ literal 16134 zcma*ObzD?k^e;SwfHWfA(%qdRf*>K?p>#8JhjdFfC^#T7AkvMb)F1*wNq2V-a1TE3 z`~Kd0|GIo&hM9BrK5MW1uC>>Wey6H{gGr7F0)cQ8-^gizKuEs8{|F2;;MGUUc^P;^ zb(2-p!T^5!F)X5h&re<6=(~YHSkE5+kp9dEB7iSN-CyguYdTxGd%btH1UbHUcX4ob zcd-3H>uKrgX6x)k%g4pb#lt~sSv#?AddH*h(-T604j7t=r>T9BgLOD*r*{dq6% z=h}0f%ZoF~$YIaLP%+*_%6tqyW5M`Fiy8B|aM}bbW~H1(NXArMt3r=}2q72qO`uu> z6_wzV>Xu+_n9MU|h8fp(Y0nx9#knvQPs04$W>?FN;Vk}9rX1!PYb%(#fqfXhY^o`m zDLQQ!exZe8A&G31tLn2h;7hmUt#JIp+!Q(PF#Ppg24A``mQ98+EIK(+=4cZPx(^gWPdr4r`fK3~%*-jDKFNfl;rLS};9JHldd^!|SiFNM5h?X$lUj5)3W%jZ^Tml^*M;C{f}M} zbLe#ztK>|7e~+ST8X)Lm8@-@8-|S)D9f4C}*pT4dejRbXJJsUYU;v${G|mxq+eo#c zl)b7s&k=g|<&QdZeUdj*jaDLObUSE!dmC{+W$J(2OX3tAIP=4@r?(e8=h!gzRgq9W zk$U88dwl!%7nHHFvAy{glHey;#4eNCx&#yyLv>RoL(zoHpvL70im2#lIwq!w-@o4h zWXa3Rqg^ieaRXy|`ucvjZ)<>xRr3ZrLr|Iyns;sfHu8>2oGMp}jOL1lPTE0~(%3+# zXlQ?GZ8deE2EB;uQ!+uj=e)eUzymYlDTM!2n=2SJIE@4&p@;l zLbZ-_@N@DXP~(<#fcF>sa~X%D z0tw~BmlOnMZ*AE;&ihp{1*F#zCl@z{Xn4S7r%E2J=~L`6j{Ee1V69Ovpm4zsn< zS6ALIUc9iG{!WJ{aRhomoZ=mJJV*gIuC!e)6xmNzBJM61Ss)|k+qy0 z>fP;SN#Nbh+1^YF@CLr!Zy0ZKv%a}JRO<-5Gn!|bi5BGIO5io`I|7vN6qp~pndiml zduD@%O)3Kj&9f!1I}#7&yWJ$4d>rY|R-e;vx>Y9a(p76~7WenJ&L+OwjPOe1p`FR{ znN}Zu0s;a`5tmMF=aaR8y~U0K910;bzAO=so#(`{y&iFPlV!a2a1ImiS#ul~hKhzqJzQNKIZ}KJmo{^Jd$^Z-%@jm)&Scv|}X2W`iWx#aJR(hfl_qT`2d18}LRXaO2R#sL( z_mOxUrg_kC$a?^b6LDR`KtaO>QQ|RK#wI3i{zRu)Ygh~{^4y>GxzE+9(0l3Nz=0MT zGFGH8{=@Puz?!#JCT)NQ{L+2^p0KnWNz-TH+Ij~lz;v?*yJ3S91mI`zYK8ReCcB)E z*&m&$AM;kM^X3^lV=<-Q`45vn<>n42GroPiTZz>{h(d{V!T(gHb4)UM#EhpAj)R7x zQ@%iv74(wt5+?`QsvpP<`sQfPWwSod6 z71fBb*Zgb1=eaW8AfCJL8PwS&B_;g?H0VU-?9p*7cZD|%vg=f29v*YGYiro60Q#oi z=3A%0i=_@{@k>~9YDn9uh9pYSxNQtCAG929Ed2}xgdYs(%lPM)C;;!b!4##Xr4yx^ z=)tz*#Z7|>iPS2)a3~p{MO1l(-{paFffQA+af>H->o;AtkmJr6_|N#be!WAMeZXp8 z{6v*0P4K5r_^@126d4;EmgVK;3cYIN;D_6e2YNth2h-RI$;bx&Hn}1F8XjH)-a%pE z;m6}@(#MF?(H5#zjkAOK95v~?iF3SNfCvG{+0?IJ8FUL9^f(;m>POi73A<=WT^W4S zz-8`<`-+T^i4>($N2OAzQYo2IDJ?_`1u{VnnQ($ka6q(zYn(p21thxpX(_e`C-a&2 zVe9J3*Bd%Dg#-2pUlr<$r|AFuGIR?LrO+3NU1#-@>?%o&k) zcNYjn$Ftg*D0Q+vc`{~j3K;XFll$=D1F5)Y#jZmjpzy8daKlF@>2+uVc+S3W>P0s5 z&4LudP8NVE1k-N^9sNYFb(+tH<%zo?uE4stf_4*TKR-T^xY;VI(68xRohm3mr}hr^ zJ>MB?_OJ)SPdA{UZ)IdakAj-9E_ig4Jv}{uO_#luO2-eRSD1>Q#5XF7)Cr$&tx7FJ zsX#TbfsV36tWaWuDS~Ng;rwYD1;{zI@B$V{1PZhcj>is(0HM^vL$Som29j~My#IH!@ zLm~<`m%*dG?c1{L9D%Lp1Nerx?GIRowUPrG%!`p40h=|<(BXh zPzx|C&^2m31BewtJ0cmopvb&igS_){Z(#=j9T*1UQT9^x_12DFWvPd?D4&Ji5j09Amdymn_~f;1?$Br`Nq$Q;C`mQQNKIYy=>Y%*T2{4dzDzPkcd-jo5eEtInpPsW;dcqR=6|0$&h7cE)BWg@;6yra_b&urC?1->E_Cms<9|Q)2VP ze^U&$|F)Jp!k$nTLptefPEK~hCzTfzoMn$!!_3<@k#ML;b4N}|qW$osUgRHyK0W+?te{ znu@%;N!iH0iQjR$IcnV%_S7VLJKyi%i)=V%W#ng2zW2)0RE=B-pFiyV__E$p(eC}- z8WiJfg!a?jL=onC4v?uaI<-DxS`m>| z3C!vW@#L?|b)ZoR30Ck5{U-BMP4-T)WGk5XwmrW%K+E-nPHtx1@5>XERaqLiIF;$Q9((60- z5w6a|nMZWLIun}U>gJe>f2`MB1sTqiA3X0v&5T~FH}B@wcw=aq;Tus6;77|9Z-#J3hZq#G7|*&lC3$EAG401Qk_e_DOq00-PIap?>osnd;- zRRFO7&LZ^7tH_hnQE8L}W(Dh!>|WELyYLwYtE;1B!1Lw-19Fa6`w0mMLPo5LtVi=5 z7Fx65P(ze=b#~hKcbBG8_gCgjs=2>XSv4gBC1s;pB`-%b(l;BITRo{)5#jpJ-b&z# z7IAl8pKeA+M}Gl8TdtVLpkUYm;F+5MuJV${Pkd7kZEO?)!r(5r1z;;b5E_X&4H}u~ z^_yH7f#}m^#`CVmN~N-CBO7^+RK$gr-x_8yk}c@I3m?&L_dfmruQFA;z1RmH@cwwE zw{k$%YBXPEuHG>^KHd^|bK+OSp%lRnX0K}fn=laX(GR+CYFCu1@;Aj`|!W5Ges!S_1f)6r1GU)E-JE z*-;B>iX3AyKXIu=`Q19+p zBE%tg>^9`T)TA3o*fM_FBIq=2~Ug4u?Ox^I;6)Tp6yBLUO0=9p`$}5`( z1c;X(+kHB zFRu>bqWH-4Nr_Rmp9-87`GoAJpggpAmh*~(~1T#rI`CxC!nUU z0TsYnJmzy1ZReJoIqSkw<6GFvJ@qy!D@SDE6`yRBGK2JZy(!}Dbie4>9QT!6x@Ue6 zExM!!#7ob}7+z7q@rXDa;f>F`rS&_5 z%@2=b&XHiKaIg2Nd+{hV}Qs0jE+OaS(E{=hY4k;^D&H@V)^9A3JvwM*+ zmIRZ2siFq3rt;pA$^UIQ)_%Huz#b$ye)_wso#8 z+pRn2XXkBnJHVPx*4|=H*A=gl)Ui$m#O@caJH2|7(fs zU#Xe-#_$8L_5A75O1kLgt3{c(e{`UjSESfjPp=!ON$0(R9PK!HnAH7M#7xW7oBc`D z6;w$KNRg)8OnS9GKh=BK@lMVFP17MD%RH8Sz8M9F`YWz7zY`4M_<`Bv%|y1I@S9|rlD9020RP|HliVNamLkuvxZ8^c8L zN=)d*u&Cz5eTp?w$MC7EJixyEZAk1PoWznv6k3MSI^DkllG;M?acvW!A8M06!M|R||@&A=Brm>p!X+ z;Z2G%&f+omD0frReeq6TakgWIgpT;lV_oU_in6a5y^8ejQjHfN&rng_LTBgcr!w&q zDiCVZ_x}n^bPibwSkQfnDWs)NTP&va1&{HeD{hbnY$N|u&yn76&v`+cmwU%z0BUyID_G(n1WIk&HakA5#n#PC zx75EY+vhHBrHp$jW!RHbhB0Q) zQ-fVW*tw|4vxn$CF0#$b9?J9GjcMs;BEH}vgWUmxT~FW_CTM2Rhb zDQDU*dOAU{A4ISF5k1<(K7djL5YGCr(OpbBxvX`uBCotZ;;=2lZ=nn&)+bF+nu58TW3}7n>)ItlYDQn^ zxjgM9XgHzfHg?x;Y3yy>TMRmc`~`l`OteW>D5&x06&}UnR(E$_vA^A}+W9A1n%8D2Hwvpwtpn1ss|0s07&~ex{dR)3Y zNH%n&XZMC-3rje;mGCI5s*62US>i<)e)zBUak|HS`T+3iFbhZD#VlcAdN znY_vRnf@Fk^?hNOx&FRK@OY6Ku^tC_Fw7$b#M1+z$VT~+;q*KAyS60BZgXxKKAboWH{4l$!&yRwL$W5C1$M*U8D;VQ1sJ^j7|1ZFm%FgVCFm6ka>?xO<%CoQlpBJuog{-u2pu*UD?@q_R#D4|`?H-sqVF|;)P>Ls+v9sAk( zn|l_@(URDnt;7!b7Nhp)R*Wo?9fRj?=#2BsU@d8^q16Jfni(Ehv+|;RpYwXqce(N^ zJt8!7pUla_;pH+1fGD_6C;#A9{d$y8&+Ec6ttITAPL}d+pXYq7ya^BLCHj|gZZfQF zdjBK-!<3m)kvt^`X>ul5jUyWHvxY=$PsT6`}`+XBaF`f@Iz6}mU~3g>~lH*U`rSFYuO?F zR#}~?XvSk%uw1ZW`6Mu*{qab za*iCuyl!?1!+#N}9GiyIOhBJg+=WD2@CBC*Ez1WXjrXTQ=S^v!F6BSP6(vnsnV}I# z)w}iFm=!ZG)stLorXrVnC;H1MW{fEDQMA8)rmvH>?zz7)mp7oMFIU2%QE=b>XFIqv z(F;y45>M@iS7jaa>HiV-OZBX{6H}m6Jvu4|Nh)FM&p@x<<8riIo^u->tlSG#Bj8o- zRo%y!qD8=l24$C>>B|qXx8F$Bho-)G$L9hP=dxGOgw@zN^GW7t_nW=zp%L$n^y(?p znmNoFWwJh#jT)MT)0axz%`+u@&9&~rD}Q>w-cjp&;Aa}SuKl>G#tJHBDfG@iRM7%a z52@nHZyUQ@p6{Xjd?y79e+-#i_GpG^4W#KcZpU^~*jG=3%dy4%Dbu_j6~+k8mbuqT zb!2;hv%cm){WZ}91DwT=x{-hCVRrsnD(dUnW7Ic-e?bIJOb6_o zL=9!n*qD{o30Fr*I_%s$9mx?m_IP8mc}&)(G59TY_H(MimXR~?3PeC?YBnSl(Q(CG18;Z^rgWbMP+oeG3 z>$^@{s0aO$v9%;%dkh`U(mz+O2u+-Y&nD!hgw?)AoPV2|yC4A^C`60lH%aD-k**A$ zSwhXAz>?MGi3-dkch0Zu9cxtsjki>^Nna4J6~wR2 zF=*MA=FYE^U*tG&_KrDQQx+8CD#1!uB zQ(B+A;^LH}>shx8nhjqM+8f!j`m2=AdYMx3+M`?i?KJrr$l_u2-Mbq3{kKk2rbMh` z_RtKZq1>U{U|gSx0T7xGoe*7*B^NEjN5Km#z1k#IaDdq)Wm$M6|9f=_;rdF|p?yW2hJFJ9y$AEGRn;qoR|lqoH_WPZ$azWB;By@~WPd%<+tg zAxX=tnA`k=a$){xYDeNiEmrgGDI8e-F{UU5PdbUi9rT=vp{Stec8t!}j8dn~AL?P*p)D81~fDn%z8X`q6;4G!iH7amU< z0%pe?Qx^O&x+yrV=0YQRbl6NxgY+K_4Wq-n+SZA$64?w~_x`LWX_JPJ3uKmEM6@yaX3t1{KRBIA+XtaGAaHg*483lb`E<)#>Cqr_Wvj+&dHmBi-2ILV$|Q_ z$~2NThxtKo{=7#t4c$fGm}YQ1`JAA{^?ko;DsO3n2KFhtyrdnG3}iM(;=o8vEi_u* zabDgx=Yt`Y`)%>NS8%>Rjs?`Zm#DNab=S{kIDityV9owszc6>n7h=e+Jg{yKp%L!- zi{N5~#W^IAJkJPB*#7cY!f${3Td(P*l3WZ8cd}Ja2komg^Tu1n?%RwUO-WOCPX^BZ zqqp9zgv|avTjhfNo1yr#;Fu63|HU)M;)c9|r(LC$8q?oBTI>rra`G-K8hC_uotSbK zm$grIr}vu_Ou_NLT(8%B9%I>q`H+}e#d|z@aRq$JB~k|tj;}8o{@#PUE;{nvsjxfe z7Gc)?#{%%Zw^qFf?rldSwaj)Nr;m(7;C@(K5bp7{>m^og#1PBa+o^c`uES}LgnN%r zUfR+9x4RNOll_t7I{O=|j4d|RcalIz(!*7T+L zf;w5oIcniX5t71>2;!cZ@$E6R4n2!N<@B!;M#Yi=ZcWMe3D4#H8*Hjh>ix_kCm?C> zaGF(1T}Blq(*>KUNqD5_o|Il2Yv~wNdJeHavZUjOOE(=k)pb&7y_A5RhjzXP_D>RO zcRP&+VilZ7pHZ<-(djSc$W%X1hEKqkN8eXUMcUqhK-9XAy#VXODd^w)5AdhRrV95i zlKlt*$;=~$Ez96jgFdqh?HYONeXbJZK?fTHdo#^L&mTj&Q+Ut z{k#vmPA#j2dx3s9AOnhv<{b*;k8P*Oga1uFTXFJ`;-9DEiV+KmM_7*`4RChL%{;IpCM?9wnDr_A1ICA24i(_2cZOhgNm z2|i4HvpY6X zCVMP3sTV%GbcU3?=f5QsKRzu+&EFzaF^CBNM9UxgY;p4@xQ;`4|4qlk-Qa_X$XhGO zo0C9lA?GJJsydtupXjJ|n$nENYkhf56=(iU_TdlAlIN`RQ~+0`Yfvq4S#eb;-}stF zXU6b%nykt=Kvcl^V2#&Wvhqfi*F&WrcYcqx%SmxC!l&Y99)4u3trEYyoN zBwZd^c2TT-sKD=H|HH@8#MPLsb~sXU@x;wBZ`=R0n~^A8=27XfRuUoa10*p|AG)%x zf~1kZ`y9ScsLF=D(pMvHbUw6hhgjLXvkmi^c~rRn2JoiQk3hRL`|FqEYI}ccGGMmSDENy_^`aumP8L@t-o7 z>YZe_3mb=4uS#7M#WQ^nVDVIoTaA;k>IB=F>Gkwx+N#)Okm85bCb><42 zBC&jBMfyQed6oJ+igZGBiF85aJlAEZ%UM``#zmgW>y+D1J%ww(IyC9H+%8p(hi*6U zMDg93rAPAAzXn_~)FM2;TI1MP8=zcvVp;PVz-B0XWr@xd8oc0o4rgXC+Q1WpxREMK3`hPPxeY35$Z~7r-Xf|)kEZO(dtBP^R&U!E=pkl%APaRY# z{*7u$F)s`uh=bGrblhk3l1-@q$Q`&|&04L?#rSCi@$4$HnRoDS&3?{0!%jQO}Szlh|{~H{HX#YfhIJpsd*x`|;g6o}8Ttb|Z z{(iu#qkEQ@RSfd0?qa?D($%bB!7rE_O65 zt+B%f?cN)2*6-J&m}d!q9olbIYtCUce@Q8kMdXtai}L~A-F&F8YIfV6S2t?8^6CHs z2cWUrwjvmv_8Z);jx>(fq~4sP0k2+l)A4)xge!fiTsPsg`)!Y~Hi_2uR`_BK)V`XP zN+C+6-jE3)$OIwm1Oqa0s8l)+J6wjjLQ-#JSnCv6>-1SC>%W?Y;di+eI1ESz-rmCI zULeIOZMIaQ$y-RGb^2!4*ln34BuJPnWgc~1N^Cb*Bdgg$b5N*46w)*}ga4-#w&eS{ z`gHf@5@D4BXBbN||0dtnPVbx^Vv{ew;zxvlafkrbu$3Q*ycJH#;VRAdv4h5{0DG4f zquZ)kpH$}jpoA(uc~|Q#VyT7;M$UsEcPFjMbNtjJ({Rsu8)za@f9{ZVs>ZPl)e_T^ zopqgUC*P93_4Sm2Jq`kzim9nI=~_=8b`)}0th^*OUbSc1oHh|m&XB$PZqhY%V+Wte z;2ffUj^AuRy@@k!!Lvqf;V?4AeG=Gt397)e`x#JFY%cIi-(O$-YizYrDGM#J9?HZo z)dkq$%&FTX67J?S=TCi4u;Krt2t<;uKt0|!4*^62%JTP@$yog+|ZsQuZ`TH{#=~~w!b90uXX%*pxl~c0)xOybXYqm8%E>NNZYse+C3w9x zH)-}!ynBodYgb$`i-_ zQP+4dA;{3`SXVQg&JIo z1C_a^)0^_QXLT5dr)!ltX>0R`xWD-mZ^*sRo~=HUeg3mysDW2-X~by#PStnFCQYWc{8ALLBA>_T&tyW_pJ7q3bC$gc!)UWi!_-jTyt3!Sdwop@nec^r9H7&1y?8~7p&r3lV%?mKFz_R^lfGtF z->kXv9%8HHM*waF3@U3lNMl#eiAVde6R~c`-}(V0j`k3aiTTA=yWdms#PV_1X7C$5 z>*lu9ve$)}THikDH$syTv1Ott|KqpGnxkFJ=SWdbT2*fxh3yvx=aw;PlE>J?S&FP4 zeuTBX^lE~ayUo^7KC@sdlP7(cr2qpZf0oW%UBVSUI-rn}s;URtGUB6=hB4@RFPB7$9*o*z)Di%xg)E4^m?F_DrOA!|%%~uwn zGLE%OpQS^gmeb+J?nifOY&DYemN9Kv=YDU1RMkoMc7|2Krg?qr{M|+GBge%vxlY1el4tc?8Hqp za&y20J>{f+vD!q~Y6xZkX-|+Tgl8m2+qnt0?2|Cr*pE0(odAmOv!DTV!2KhvrOsT! z`xOL(?a7nh=go8T_0|SIzEP-$oEuA7LffL}>ci{Hz3(QYA;je@bN@z|qT-s{z}?&r zR^J@$7v&rmyKxmP8n&vMy?X+RINMe|CDA#Jg-U`9_tbkN&!N}?OcG2Dx|qxKL?2P2 zZ6?r*uDcvlM&oWlSHUJElhEfjD^Zo0!OIcCPoI_>_=d#r0UI2>mh{~p=q1N@c6p3^ z4buOd?2#w#D&YEtj-6Y-<1SWsD$h7b57h56;Ps>8lr+VxJIm{YFBo<{l2BWES$%Jw7Z+_<6OFLJHg@#WS6OsD4&TF#_6 zoo@cU!JCWB=dF-Va~dg+1hhr>wPw+gZ^eI3pk9dT08)!JMRm+U_rj_GD=gMDtL)7&-t-ECyu*5;w?SW8z_EriipFHY*2+bSPu4Sq_A^n75 z=~_M+vpvb?Q}2;4Bd_BfKMIq4(z!-%uAizE-gMDFFu{au>M30=?Y~2bo-#V-aYI!3 zL!Thg^q7{cv4i$L?PnUX^me82YzX?oN3}|MFCNg7)&WuNw`k9Z`*i)VgkVRux(JGo;DQBskH7sOZhBA#{M{Ym-MfblQ zDzE@r!zj}ZhY?_|lm%ZT*FdG3xv~0_Aca34y=ay#PX$29)C*nJxA4;od*^q|9F3iK zmClPF<2k7cFjL$uI3_Dw3NW~a0P|XxYDSV&S;0;^s1N6whm|*&p$e$oO-Rd$uNM@ za{If1Ble6y9D%iTSVp(rk(xw~*I}e?m-@p{iy!jRRXe9ezO-gcQhFSwQ2#uqqFAb( z;I4Xk{${kNSqFtr`MGSuLIdwqy?wUMCft)GUmmAaF9c+{T3=wEb-ga0;J3$&ZPCz% zyDb()bEAC>q2fkYuMqpA7%ure!UB}mEA71*4g2~!;z-3<(xE|KdyxI%`iWsK(hLK@)3xN?8R}}%F~nu#7^MH= zWs98Z^c|L|%fKV@Sp+sb;>f2*ikfi@yu#}iL1xn(l&23S%j6(J4!kYZ%T1D_ju#5F zaszCq(f1$ZT}_Q(%A)e`4O($5wI7-*GS6IWUe+G+exkP)H08bu zC1g%GPV)_q5Zz&v_Q++Ud*W64T>IS)HOHXQiu0B)ujG5ExzBgotlRpyJVt+ax|kB> zMURw>TWLge7=5IT^YlRZMinU2c{i+jN{?!&jhe3B&?Rb!myx|p>k@If!e>sP{H(M-D3DF1 zTj3e2WIr;If#z1Vt*fhFF#HrjE|NXcfKc4s%6ul-jxXxtJEhX}_KY}(>WLm7jQ6k# z2U~xVd(`)B;Uew%+EcW@(&Wk^CZe9U-}M})_p&RFJxVKJO@q2mJW8(HXb4P-@(u4e zV&g5V&I%jA0r~ru?VpsFt`N6J+@4$YrlndXPYAvw_;ou9QRox1*AKh1waxJ?-X-7} z_vHr#e%Y;jTKS`Hf5B=qi2-fFmAUx07^S%DCz=lbP*`aG*H`ZRx@}+Y48I9M?Y~qz z)(SIhq~TC^q`$3pQudoA^Q?v~gn3p~aHg4Kf~$vw#x~tI{E6wDwb;L_c0sYC9oF?9 zDynRuqEeM~brY-&C%|s!M3AMIl%J@>Om!#|fAja+6r2 zm=pGdKQS`l-^2>h5XtkWFVq!)H=m<_>PUdmnCOfAm?eYXTP+&P8<73peA)Qa< z?SPs3rv%8Mf@1plN{;lq6(!s+=OM1jbX-i))crGewbfon!Q0ll`dz=%J#7 z(@%4>=$2rSd-PlNMVXf6UGa$f?RK{8oEYy3i(uEu_AC+~R7i-spg%2WA@U{Bep`d1 zo-crw7=EvTL^JmsqRcq-5nZ9DfF#}&8SX2cW%$*s{-b4WpM=D{;!_3 zjsIM$QO*;MtyWZXmDBwK8@d${tj8r_o7c7u{~|fxhfsgf&mDtvoA6_IN!=;dez*B8 z%eFh)!gb}!er?CDcA;JRUw2o9%fru}p;k_ovrf#XM&#w~ei?)c7j8xCx}J3u z3MtfH)pre5HVcj*I&FGMsR%eZ@{Fk?;sz^;+U*DrVHkjgItXwH8u0lmRhKTet7lE%VSe0^~xMBwt&qJ zRfj`fPLvu8PfH+Rs+-U!FV7)&5iWr_bJc1LBq1$12l-{y`;RW>!zJph3~JT%&FRdl;`F| zH)kUc)9Vo4gqsTnsoZLyEvN(D0ms?9)9a;ib-{ptbJT7j8o z*pCUooY0W3V1T^;8@>4E*JAC!j^joRFc%+kOR$Lya>6Et^OS+}s56Zz(@k!Lkhr1g zu4>!}Z~m2(pNd`E_xSPBlIwtlhq0PN{1?o^++T@A94cbpA3dnIfU&JLRp0S4P^PV# z1Q>3J;^r$emRaFo%Wr1`1%*Uz!T@HoTzGS$+np!~dcJ$TzsemgRU+B1Iz~Gj#Vc|- zo=-LqIdi*?QY+#2zNgFFi=#*n+=}0om@3!t(nOzYsviw{ZUOZWhkCTw zO=1T6YGVK`y=iiVY9Ln=?Ksqg^iD8v*3kPi!?Qbs&(#`bAsTETQsiOokX4{}?kITb zcB>Aq1DP=ItP*jmLTK2xjm-4}U2Mx)&$3Eh+P7ioX+3iUI?-6jo1zW>=lJ1&rwC!( zXo8wbj7aFQO@7)-UrD-~w4SN`WXMNcYjV&YKkuViDXpsGI(x~`@#ZW;mbDI+q7eKx zwnvjEnmOqHIo2DA@Z$z=%oqRvgNc426VFyfg&%4`u7u;$DP|k zP+-PZnubT3#@jTF=HHXYBb6m6Y3*GcMo-x za84~HluAh<6L!`VIcXZ90e7chr>crnvBK1w-&4mdkR4V?pj&;NF)Pvfs`r9>J;7mx z=GSPn7=pL_n|=(MtmkL19gRy;XSd_r+|`4)7UGyYJpGB(5-#HYHI0S0Cn&HI6{ltc zZ2-#-Rhr-rC*;sN(}3m7?joq0C~ALg7-z6>$QbNotdjz^P7z!HjtgBR&|Bq51YL-B zM2cs02au`}ey(GCc2)^w0&k2lQMgC?fqn?4u&G&F@5) znv(Bl)=1O>_pkVROsf!|XrbAFX>C3yX?MH}@mk2a_A@nuB16 zlX;UT+0EZok=EN|n61UBTo4(HyXD@g8fZ(7W)qN}C8)QH|B9lz(%ll`>Mq??S>Q0m zyB1y^0uhn&q3TYuS$!*#j=0)sGn(-9CmRL&8-njNR*p0za6%ZC*f;%rVl>JMg;&_P zI#m9Tg5mg+)LXXvJx@EN2lT(?bzB!Yf3S|R(TQ!Lc$?MpB*&S-PMzZ-QnG9DAGvWcF+edRSuK5 z62hZQjU5mVL8Bq7;Lpfo1`tK<<6#sXGp+<_V$)uJ(3PQmUS*wX|5)N;b(r};V%5UX zYsY@wV|Sz*@x>v2FhcXb?{OT^M!2UY>c+C+H)Dw40?2rN^aQ`EE|9su_*&*7kH6dH ztiUp35lRU(1Huw@JCNJbG?roIYi)U!Qqc;c#o7phD+BvGWA)V|PYHuv@jCcKhJ#gUs?vQuzmtaN(3W^X?(|do{S|7aLj@`bTjw%zF zXFW(W1VnS+9w)*z(YJa bool: + try: + with open(path, 'r', encoding='utf-8') as f: + nb = json.load(f) + except Exception as e: + # Skip files that aren't valid JSON ipynb + return False + + changed = False + + # Clean cells + cells = nb.get('cells') or [] + for cell in cells: + if cell.get('cell_type') == 'code': + if cell.get('outputs'): + cell['outputs'] = [] + changed = True + if cell.get('execution_count') is not None: + cell['execution_count'] = None + changed = True + # Trim noisy metadata + md = cell.get('metadata') or {} + removed = False + for k in list(md.keys()): + if k in CELL_META_KEYS_TO_REMOVE: + md.pop(k, None) + removed = True + if removed: + cell['metadata'] = md + changed = True + + # Clean top-level metadata + md = nb.get('metadata') or {} + removed = False + for k in list(md.keys()): + if k in HEAVY_METADATA_KEYS: + md.pop(k, None) + removed = True + if removed: + nb['metadata'] = md + changed = True + + if changed: + # Minify JSON to reduce file size + with open(path, 'w', encoding='utf-8') as f: + json.dump(nb, f, ensure_ascii=False, separators=(',', ':')) + return changed + + +ess_processed = 0 + + +def main(root: str) -> int: + cleaned = 0 + for dirpath, dirnames, filenames in os.walk(root): + if '.git' in dirpath: + continue + for name in filenames: + if name.endswith('.ipynb'): + nb_path = os.path.join(dirpath, name) + if clean_notebook_file(nb_path): + cleaned += 1 + print(f"cleaned {nb_path}") + print(f"Done. Cleaned {cleaned} notebooks.") + return 0 + + +if __name__ == '__main__': + sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else '.'))