From fff9444da55d046fb33d6caaac6bf9b9048cf2a2 Mon Sep 17 00:00:00 2001 From: Jelle Treep <40466121+jelletreep@users.noreply.github.com> Date: Wed, 27 Sep 2023 17:50:29 +0200 Subject: [PATCH] last minor revisions from pilot (#79) --- book/Introduction_to_python_1.ipynb | 2 +- book/Introduction_to_python_2.ipynb | 4 +- book/Introduction_to_python_3.ipynb | 12 +- book/Introduction_to_python_4.ipynb | 2 +- book/_quarto.yml | 4 + book/data-science-with-pandas-1.ipynb | 43 +- book/data-science-with-pandas-2.ipynb | 14 +- book/data-science-with-pandas-3.ipynb | 17 +- book/data-science-with-pandas-4.ipynb | 10 +- book/installation-and-setup.qmd | 19 +- .../afternoon_exercises_solutions.ipynb | 1337 +++++++++++++++++ .../morning_exercises_solutions.ipynb | 301 +++- course_materials/afternoon_exercises.ipynb | 174 ++- .../empty_notebook_for_coding_along.ipynb | 92 ++ course_materials/morning_exercises.ipynb | 45 +- .../afternoon_exercises_solutions.ipynb | 425 ------ 16 files changed, 1887 insertions(+), 614 deletions(-) create mode 100644 book/solutions/afternoon_exercises_solutions.ipynb rename {course_materials => book}/solutions/morning_exercises_solutions.ipynb (62%) create mode 100644 course_materials/empty_notebook_for_coding_along.ipynb delete mode 100644 course_materials/solutions/afternoon_exercises_solutions.ipynb diff --git a/book/Introduction_to_python_1.ipynb b/book/Introduction_to_python_1.ipynb index 4b2f6ef..bb93656 100644 --- a/book/Introduction_to_python_1.ipynb +++ b/book/Introduction_to_python_1.ipynb @@ -273,7 +273,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/book/Introduction_to_python_2.ipynb b/book/Introduction_to_python_2.ipynb index fca6fd1..3ecbe26 100644 --- a/book/Introduction_to_python_2.ipynb +++ b/book/Introduction_to_python_2.ipynb @@ -76,7 +76,7 @@ "When we want to make use of a function (referred to as calling the function), we type the name of the function followed by parentheses. Between the parentheses we can pass arguments.\n", "\n", "**Arguments**\n", - "We typically provide a function with 'arguments' to tell python which values or variables are used to perform the body of the function. In the example below `type` is the function name and `pi_value` is the argument." + "Arguments are used by a function to perform the body of the function with the value of this argument. In the example below `type` is the function name and `pi_value` is the argument." ] }, { @@ -397,7 +397,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/book/Introduction_to_python_3.ipynb b/book/Introduction_to_python_3.ipynb index 118aca0..a585a31 100644 --- a/book/Introduction_to_python_3.ipynb +++ b/book/Introduction_to_python_3.ipynb @@ -522,7 +522,7 @@ "source": [ "## Dictionaries\n", "\n", - "A dictionary is another way to store multiple items into one object. In dictionaries, however, this is done with keys and values. This can be useful for several reasons, one example is to store model settings, parameters or variable values for multiple scenarios." + "A dictionary is another way to store multiple items into one object. In dictionaries, however, this is done with keys and values. In dictionaries, keys are typically use to look up values. A good analogy may be the contact list in your phone where you use a name (key) to lookup a phone number (value). This can be useful for several reasons, one example is to store model settings, parameters or variable values for multiple scenarios. " ] }, { @@ -532,7 +532,7 @@ "metadata": {}, "outputs": [], "source": [ - "my_dict = {'one': 'first', 'two': 'second'}\n", + "my_dict = {'one': 1, 'two': 2}\n", "my_dict" ] }, @@ -569,7 +569,7 @@ "metadata": {}, "outputs": [], "source": [ - "my_dict['third'] = 'three'\n", + "my_dict['three'] = 3\n", "my_dict" ] }, @@ -578,7 +578,7 @@ "id": "1043ec01", "metadata": {}, "source": [ - "Dictionary items are key-value pairs. The keys are changeable and unique. The values are changable, but not necessarily unique." + "Dictionary items are key-value pairs. The keys are changeable and always have to be unique (within a dictionary object). The values within a dictionary are changable, and don't have to be unique." ] }, { @@ -588,7 +588,7 @@ "metadata": {}, "outputs": [], "source": [ - "my_dict['two'] = 'three'\n", + "my_dict['two'] = 5\n", "my_dict" ] }, @@ -738,7 +738,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/book/Introduction_to_python_4.ipynb b/book/Introduction_to_python_4.ipynb index 603ecc1..f3ac93f 100644 --- a/book/Introduction_to_python_4.ipynb +++ b/book/Introduction_to_python_4.ipynb @@ -168,7 +168,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/book/_quarto.yml b/book/_quarto.yml index 69525cf..0a3b4cf 100644 --- a/book/_quarto.yml +++ b/book/_quarto.yml @@ -28,6 +28,10 @@ book: - data-science-with-pandas-2.ipynb - data-science-with-pandas-3.ipynb - data-science-with-pandas-4.ipynb + - part: "Exercises solutions" + chapters: + - solutions/morning_exercises_solutions.ipynb + - solutions/afternoon_exercises_solutions.ipynb - what-next.qmd - references.qmd repo-url: https://github.com/UtrechtUniversity/workshop-introduction-to-python diff --git a/book/data-science-with-pandas-1.ipynb b/book/data-science-with-pandas-1.ipynb index 800957c..3d1cdc8 100644 --- a/book/data-science-with-pandas-1.ipynb +++ b/book/data-science-with-pandas-1.ipynb @@ -25,7 +25,7 @@ "\n", "A library (aka package) is a collection of files (aka python scripts) that contains **functions** that can be used to perform specific tasks. A library may also contain data. The functions in a library are typically related and used for a specific purpose, e.g. there are libraries for plotting, handling audio data and machine learning and many many more. Some libraries are built into python, but most packages need to be installed before you can use it.\n", "\n", - "Important to add: libraries are developed and maintained by other Python users. A popular library like Pandas has a large user base and the maintainers are supported by several funders, which makes it a reliable library that is updated very frequently. But this is not always the case, on the other side of the spectrum, a library can also be published once and not maintained at all.\n", + "Libraries are developed and maintained by other Python users. That is why there are so many packages and this is great: there is a huge variety of functions available that you can use instead of programming them yourself. But it is important to be aware that the quality can differ. A popular library like Pandas has a large user base and the maintainers are supported by several funders, which makes it a reliable library that is updated very frequently. But this is not always the case, on the other side of the spectrum, a library can also be published once, badly designed/documented and/or not maintained at all. To check the quality of a library, you can check e.g. the number of downloads, the number of contributors, the number of open issues, the date of the last update and the number of stars on GitHub.\n", "\n", "## Pandas\n", "The python library [**Pandas**](https://pandas.pydata.org/about/) is a popular open-source data analysis and data manipulation library for Python which was developed in 2008. The library has some similarities with R, mainly related to the DataFrame data type that is used to handle table like datasets.\n", @@ -212,29 +212,6 @@ "It is, however, enough for a quick exploration of how the dataset looks like in terms of columns names, values, and potential reading errors." ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - "Exercise 1\n", - " \n", - "Now go to the Jupyter Dashboard in your internet browser and open the notebook `afternoon_exercises.ipynb` and do exercise 1.\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "::: {.callout-note}\n", - "As you can see in this exercise a DataFrame object comes with several methods that can be applied to the DataFrame. A method is similar to a function, but it can only be applied to the object it belongs to and has a different notation than a function.\n", - "\n", - "Compare the notation of the function `len`: `len(surveys_df)` \n", - "with the DataFrame specific method `shape`: `surveys_df.shape`\n", - ":::" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -356,12 +333,24 @@ "metadata": {}, "source": [ "
\n", - "Exercise 2\n", + "Exercises 0 and 1\n", " \n", - "Now go to the Jupyter Dashboard in your internet browser and continue with exercise 2.\n", + "Now go to the Jupyter Dashboard in your internet browser and continue with exercises 0 and 1.\n", "
" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "::: {.callout-note}\n", + "As you can see in this exercise a DataFrame object comes with several methods that can be applied to the DataFrame. A method is similar to a function, but it can only be applied to the object it belongs to and has a different notation than a function.\n", + "\n", + "Compare the notation of the function `len`: `len(surveys_df)` \n", + "with the DataFrame specific method `shape`: `surveys_df.shape`\n", + ":::" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -439,7 +428,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.8.10" }, "vscode": { "interpreter": { diff --git a/book/data-science-with-pandas-2.ipynb b/book/data-science-with-pandas-2.ipynb index 3aa722a..6f5bc4e 100644 --- a/book/data-science-with-pandas-2.ipynb +++ b/book/data-science-with-pandas-2.ipynb @@ -353,9 +353,9 @@ "metadata": {}, "source": [ "
\n", - "Exercise 3 to 5\n", + "Exercise 2 to 4\n", " \n", - "Now go to the Jupyter Dashboard in your internet browser and continue with the afternoon exercises 3 to 5." + "Now go to the Jupyter Dashboard in your internet browser and continue with the afternoon exercises 2 to 4." ] }, { @@ -669,9 +669,9 @@ "metadata": {}, "source": [ "
\n", - "Exercise 6 and 7\n", + "Exercise 5 and 6\n", "\n", - "Now go to the Jupyter Dashboard in your internet browser and continue with the afternoon exercises 6 and 7." + "Now go to the Jupyter Dashboard in your internet browser and continue with the afternoon exercises 5 and 6." ] }, { @@ -869,9 +869,9 @@ "metadata": {}, "source": [ "
\n", - "Exercise 8 to 10\n", + "Exercise 7 to 9\n", " \n", - "Now go to the Jupyter Dashboard in your internet browser and continue with the afternoon exercises 8 to 10." + "Now go to the Jupyter Dashboard in your internet browser and continue with the afternoon exercises 7 to 9." ] }, { @@ -899,7 +899,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/book/data-science-with-pandas-3.ipynb b/book/data-science-with-pandas-3.ipynb index e7400c7..d3bf853 100644 --- a/book/data-science-with-pandas-3.ipynb +++ b/book/data-science-with-pandas-3.ipynb @@ -193,17 +193,6 @@ "vertical_stack.reset_index()" ] }, - { - "cell_type": "markdown", - "id": "f1db04a6-8ae2-44e4-9798-adc1b108c9d8", - "metadata": {}, - "source": [ - "
\n", - "Exercise 11\n", - " \n", - "Now go to the Jupyter Dashboard in your internet browser and continue with exercise 11.\n" - ] - }, { "cell_type": "markdown", "id": "7bc415a6", @@ -315,9 +304,9 @@ "metadata": {}, "source": [ "
\n", - "Exercise 12\n", + "Exercise 10 and 11\n", " \n", - "Now go to the Jupyter Dashboard in your internet browser and continue with exercise 12.\n" + "Now go to the Jupyter Dashboard in your internet browser and continue with exercise 10 and 11.\n" ] }, { @@ -508,7 +497,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.8.10" } }, "nbformat": 4, diff --git a/book/data-science-with-pandas-4.ipynb b/book/data-science-with-pandas-4.ipynb index a4a9abe..99aced6 100644 --- a/book/data-science-with-pandas-4.ipynb +++ b/book/data-science-with-pandas-4.ipynb @@ -439,9 +439,9 @@ "metadata": {}, "source": [ "
\n", - "Exercise 13\n", + "Exercise 12\n", " \n", - "Now go to the Jupyter Dashboard in your internet browser and continue with exercise 13.\n", + "Now go to the Jupyter Dashboard in your internet browser and continue with exercise 12.\n", "
" ] }, @@ -488,9 +488,9 @@ "metadata": {}, "source": [ "
\n", - "Exercise 14\n", + "Exercise 13\n", " \n", - "Now go to the Jupyter Dashboard in your internet browser and continue with exercise 14.\n", + "Now go to the Jupyter Dashboard in your internet browser and continue with exercise 13.\n", "
" ] }, @@ -564,7 +564,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.8.10" }, "toc": { "base_numbering": 1, diff --git a/book/installation-and-setup.qmd b/book/installation-and-setup.qmd index 08be8bf..6a0ace9 100644 --- a/book/installation-and-setup.qmd +++ b/book/installation-and-setup.qmd @@ -72,7 +72,7 @@ version 9 and below, are not). 3. Move the downloaded zip to the folder where you want to store these course materials. 4. Unzip the zip file. -In your `python-workshop` you will see two folders called `data` and `solutions` and the following files: +In your `python-workshop` you will see a folders called `data` and the following files: ``` python-workshop @@ -82,11 +82,9 @@ python-workshop │ ├── species.csv │ ├── surveys.csv │ └── plots.csv -├── solutions -│ ├── morning_exercises_solutions.ipynb -│ └── afternoon_exercises_solutions.ipynb ├── morning_exercises.ipynb -└── afternoon_exercises.ipynb +├── afternoon_exercises.ipynb +└── empty_notebook_for_code_along.ipynb ``` ## Launch Python interface @@ -139,9 +137,12 @@ Make your choice and click "Ok, and don't show again" button. 2. Find the "Notebook" tab and click on the "Launch" button. Anaconda will open a new browser window or tab with a Notebook Dashboard showing you the contents of your Home (or User) folder. -3. Navigate to the `python-workshop` directory by clicking on the directory names leading to it. -`Desktop` and then `python-workshop`: -4. Launch the notebook by clicking on the "New" button and then selecting "Python 3". +3. Navigate to the `data` directory by clicking on the directory names leading to it. +`Desktop`, `python-workshop`, then `data`: +4. Launch the notebook called `empty_notebook_for_code_along.ipynb` by clicking on it. +5. Run the first code cell just below "Test installation" by clicking on it and then click on the 'play button'. +If the output of the cell displays 4 version numbers and the words "No errors! Ready to code!" instead of an error message, your installation is successful. If not, contact us at [RDM walk in hours][walk-in-hours] or reply to the welcome email. + ::: ### Option B: IPython interpreter @@ -176,7 +177,7 @@ This workshop will make use of the following Python packages: - `matplotlib` - `numpy` -Anaconda Navigator comes with these packages, so you are ready to go. If you are using another option to work with Python, you need to install these packages. If you need help with this, please ask the internet, your colleagues or us (see welcome email). +Anaconda Navigator comes with these packages, so you are ready to go. If you are using another option to work with Python, you need to install these packages. We then assume that you know how to install packages, otherwise we recommend using Anaconda instead. If for some reason you cannot work with Anaconda and you need help with installing packages, we are happy to help during the [RDM walk in hours](https://www.uu.nl/en/research/research-data-management/workshops/walk-in-hours-research-data-and-software), or email us by replying to the welcome email. ## References {.unnumbered} diff --git a/book/solutions/afternoon_exercises_solutions.ipynb b/book/solutions/afternoon_exercises_solutions.ipynb new file mode 100644 index 0000000..7c53bbe --- /dev/null +++ b/book/solutions/afternoon_exercises_solutions.ipynb @@ -0,0 +1,1337 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "14f401b8-2d1d-4a01-a3c8-ed2c59e66d29", + "metadata": {}, + "source": [ + "---\n", + "format: html\n", + "execute: \n", + " enabled: true\n", + " error: true\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "67d94b6e", + "metadata": {}, + "source": [ + "# Afternoon Exercises: Working with data {.unnumbered}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2c6372a4", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "surveys_df = pd.read_csv('../../course_materials/data/surveys.csv') # in your notebook the path should be 'data/surveys.csv'" + ] + }, + { + "cell_type": "markdown", + "id": "507d1c2c-98b8-4a67-b2e5-b3a3031a5b5f", + "metadata": {}, + "source": [ + "### Exercise 0\n", + "\n", + "Type the following commands and check the outputs. Can you tell what each command does? What is the difference between commands with and without parenthesis?\n", + "\n", + "```python\n", + "surveys_df.shape # Answer: the dimensions of the dataframe\n", + "surveys_df.columns # Answer: the column names of the dataframe\n", + "surveys_df.index # Answer: the index (row labels) of the dataframe\n", + "surveys_df.dtypes # Answer: the data types of each column\n", + "surveys_df.head() # Answer: the first n rows of the dataframe\n", + "surveys_df.tail() # Answer: the last n rows of the dataframe\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "0514bad4-1266-4553-9752-29dcf3166d21", + "metadata": {}, + "source": [ + "### Exercise 1\n", + "Perform some basic statistics on the weight column. For practical reasons, it can be useful to first create a variable `weight` that contains the just the weight column. It will make the code look a bit cleaner. Can you tell what each method listed below does? Look at our explorative plot, do the statistics make sense?\n", + "\n", + "```python\n", + "weight=surveys_df['weight'] # Answer: creates a new variable that contains the weight column\n", + "weight.min() # Answer: the minimum value of the weight column\n", + "weight.max() # Answer: the maximum value of the weight column\n", + "weight.mean() # Answer: the mean value of the weight column\n", + "weight.std() # Answer: the standard deviation of the weight column\n", + "weight.count() # Answer: the number of non-NaN values in the weight column\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "2bcb581f", + "metadata": {}, + "source": [ + "### Exercise 2\n", + "- Swap the order of column names in `surveys_df[['plot_id', 'species_id']]`\n", + "- Repeat one of the column names like `surveys_df[['plot_id', 'plot_id', 'species_id']]`.\n", + "What do the results look like and why? \n", + "\n", + "> Answer: the column names are repeated and the data is displayed twice. Column names do not have to be unique.\n", + "\n", + "- Which error occurs in `surveys_df['plot_id', 'species_id']` and why? \n", + "\n", + "> Answer: KeyError: ('plot_id', 'species_id'). The column names are not in a list. We need double square brackets to select multiple columns.\n", + "\n", + "- Which error occurs in `surveys_df['speciess']`? \n", + "\n", + "> Answer: KeyError: 'speciess'. The column name does not exist. Typo." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3731f5fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " species_id plot_id\n", + "0 NL 2\n", + "1 NL 3\n", + "2 DM 2\n", + "3 DM 7\n", + "4 DM 3\n", + "... ... ...\n", + "35544 AH 15\n", + "35545 AH 15\n", + "35546 RM 10\n", + "35547 DO 7\n", + "35548 NaN 5\n", + "\n", + "[35549 rows x 2 columns]\n" + ] + } + ], + "source": [ + "print(surveys_df[['species_id', 'plot_id']])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b71788b1", + "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", + "
plot_idplot_idspecies_id
022NL
133NL
222DM
377DM
433DM
............
355441515AH
355451515AH
355461010RM
3554777DO
3554855NaN
\n", + "

35549 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " plot_id plot_id species_id\n", + "0 2 2 NL\n", + "1 3 3 NL\n", + "2 2 2 DM\n", + "3 7 7 DM\n", + "4 3 3 DM\n", + "... ... ... ...\n", + "35544 15 15 AH\n", + "35545 15 15 AH\n", + "35546 10 10 RM\n", + "35547 7 7 DO\n", + "35548 5 5 NaN\n", + "\n", + "[35549 rows x 3 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "surveys_df[['plot_id', 'plot_id', 'species_id']]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bb68a995", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unexpected exception formatting exception. Falling back to standard exception\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexes/base.py\", line 3802, in get_loc\n", + " return self._engine.get_loc(casted_key)\n", + " File \"pandas/_libs/index.pyx\", line 138, in pandas._libs.index.IndexEngine.get_loc\n", + " File \"pandas/_libs/index.pyx\", line 165, in pandas._libs.index.IndexEngine.get_loc\n", + " File \"pandas/_libs/hashtable_class_helper.pxi\", line 5745, in pandas._libs.hashtable.PyObjectHashTable.get_item\n", + " File \"pandas/_libs/hashtable_class_helper.pxi\", line 5753, in pandas._libs.hashtable.PyObjectHashTable.get_item\n", + "KeyError: ('plot_id', 'species_id')\n", + "\n", + "The above exception was the direct cause of the following exception:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3460, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"/tmp/ipykernel_16478/997369930.py\", line 1, in \n", + " surveys_df['plot_id', 'species_id']\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/frame.py\", line 3807, in __getitem__\n", + " indexer = self.columns.get_loc(key)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexes/base.py\", line 3804, in get_loc\n", + " raise KeyError(key) from err\n", + "KeyError: ('plot_id', 'species_id')\n", + "\n", + "During handling of the above exception, another exception occurred:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2057, in showtraceback\n", + " stb = self.InteractiveTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1288, in structured_traceback\n", + " return FormattedTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1177, in structured_traceback\n", + " return VerboseTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1030, in structured_traceback\n", + " formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 935, in format_exception_as_a_whole\n", + " self.get_records(etb, number_of_lines_of_context, tb_offset) if etb else []\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 987, in get_records\n", + " style = stack_data.style_with_executing_node(style, self._tb_highlight)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/stack_data/core.py\", line 455, in style_with_executing_node\n", + " class NewStyle(style):\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 91, in __new__\n", + " ndef[4] = colorformat(styledef[3:])\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 58, in colorformat\n", + " assert False, \"wrong color format %r\" % text\n", + "AssertionError: wrong color format 'ansiyellow'\n" + ] + } + ], + "source": [ + "surveys_df['plot_id', 'species_id'] " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b74edc72", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unexpected exception formatting exception. Falling back to standard exception\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexes/base.py\", line 3802, in get_loc\n", + " return self._engine.get_loc(casted_key)\n", + " File \"pandas/_libs/index.pyx\", line 138, in pandas._libs.index.IndexEngine.get_loc\n", + " File \"pandas/_libs/index.pyx\", line 165, in pandas._libs.index.IndexEngine.get_loc\n", + " File \"pandas/_libs/hashtable_class_helper.pxi\", line 5745, in pandas._libs.hashtable.PyObjectHashTable.get_item\n", + " File \"pandas/_libs/hashtable_class_helper.pxi\", line 5753, in pandas._libs.hashtable.PyObjectHashTable.get_item\n", + "KeyError: 'speciess'\n", + "\n", + "The above exception was the direct cause of the following exception:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3460, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"/tmp/ipykernel_16478/158671928.py\", line 1, in \n", + " surveys_df['speciess']\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/frame.py\", line 3807, in __getitem__\n", + " indexer = self.columns.get_loc(key)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexes/base.py\", line 3804, in get_loc\n", + " raise KeyError(key) from err\n", + "KeyError: 'speciess'\n", + "\n", + "During handling of the above exception, another exception occurred:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2057, in showtraceback\n", + " stb = self.InteractiveTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1288, in structured_traceback\n", + " return FormattedTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1177, in structured_traceback\n", + " return VerboseTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1030, in structured_traceback\n", + " formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 935, in format_exception_as_a_whole\n", + " self.get_records(etb, number_of_lines_of_context, tb_offset) if etb else []\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 987, in get_records\n", + " style = stack_data.style_with_executing_node(style, self._tb_highlight)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/stack_data/core.py\", line 455, in style_with_executing_node\n", + " class NewStyle(style):\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 91, in __new__\n", + " ndef[4] = colorformat(styledef[3:])\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 58, in colorformat\n", + " assert False, \"wrong color format %r\" % text\n", + "AssertionError: wrong color format 'ansiyellow'\n" + ] + } + ], + "source": [ + "surveys_df['speciess']" + ] + }, + { + "cell_type": "markdown", + "id": "119b576b", + "metadata": {}, + "source": [ + "### Exercise 3\n", + "What happens when you call:\n", + "\n", + "- `surveys_df[0:1]` Answer: shows the first row of the dataframe\n", + "- `surveys_df[:4]` Answer: shows the first 4 rows of the dataframe from index 0 to index 3\n", + "- `surveys_df[:-1]` Answer: shows all rows of the dataframe except the last row" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bd3b4c74", + "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", + "
record_idmonthdayyearplot_idspecies_idsexhindfoot_lengthweight
0171619772NLM32.0NaN
1271619773NLM33.0NaN
2371619772DMF37.0NaN
3471619777DMM36.0NaN
4571619773DMM35.0NaN
..............................
35543355441231200215USNaNNaNNaN
35544355451231200215AHNaNNaNNaN
35545355461231200215AHNaNNaNNaN
35546355471231200210RMF15.014.0
3554735548123120027DOM36.051.0
\n", + "

35548 rows × 9 columns

\n", + "
" + ], + "text/plain": [ + " record_id month day year plot_id species_id sex hindfoot_length \\\n", + "0 1 7 16 1977 2 NL M 32.0 \n", + "1 2 7 16 1977 3 NL M 33.0 \n", + "2 3 7 16 1977 2 DM F 37.0 \n", + "3 4 7 16 1977 7 DM M 36.0 \n", + "4 5 7 16 1977 3 DM M 35.0 \n", + "... ... ... ... ... ... ... ... ... \n", + "35543 35544 12 31 2002 15 US NaN NaN \n", + "35544 35545 12 31 2002 15 AH NaN NaN \n", + "35545 35546 12 31 2002 15 AH NaN NaN \n", + "35546 35547 12 31 2002 10 RM F 15.0 \n", + "35547 35548 12 31 2002 7 DO M 36.0 \n", + "\n", + " weight \n", + "0 NaN \n", + "1 NaN \n", + "2 NaN \n", + "3 NaN \n", + "4 NaN \n", + "... ... \n", + "35543 NaN \n", + "35544 NaN \n", + "35545 NaN \n", + "35546 14.0 \n", + "35547 51.0 \n", + "\n", + "[35548 rows x 9 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "surveys_df[0:1]\n", + "surveys_df[:4] \n", + "surveys_df[:-1] " + ] + }, + { + "cell_type": "markdown", + "id": "4fc54c12", + "metadata": {}, + "source": [ + "### Exercise 4\n", + "What happens in the following two examples?\n", + "\n", + "- ```surveys_df.iloc[0:4, 1:4]```;\n", + "- ```surveys_df.loc[0:4, 1:4]```.\n", + "\n", + "How are the two commands different? \n", + "\n", + "> Answer: iloc uses integer indices, loc uses labels. The first command will return the first 4 rows and the columns with integer indices 1, 2 and 3. The second command will return the first 4 rows and the columns with labels 1, 2 and 3. Since there are no columns with these labels, the second command will return an error." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6680a6fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " month day year\n", + "0 7 16 1977\n", + "1 7 16 1977\n", + "2 7 16 1977\n", + "3 7 16 1977\n", + "Unexpected exception formatting exception. Falling back to standard exception\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3460, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"/tmp/ipykernel_16478/1314140639.py\", line 2, in \n", + " surveys_df.loc[0:4, 1:4] # the function loc works with indices for rows (0:4),\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexing.py\", line 1067, in __getitem__\n", + " return self._getitem_tuple(key)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexing.py\", line 1256, in _getitem_tuple\n", + " return self._getitem_tuple_same_dim(tup)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexing.py\", line 924, in _getitem_tuple_same_dim\n", + " retval = getattr(retval, self.name)._getitem_axis(key, axis=i)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexing.py\", line 1290, in _getitem_axis\n", + " return self._get_slice_axis(key, axis=axis)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexing.py\", line 1324, in _get_slice_axis\n", + " indexer = labels.slice_indexer(slice_obj.start, slice_obj.stop, slice_obj.step)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexes/base.py\", line 6559, in slice_indexer\n", + " start_slice, end_slice = self.slice_locs(start, end, step=step)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexes/base.py\", line 6767, in slice_locs\n", + " start_slice = self.get_slice_bound(start, \"left\")\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexes/base.py\", line 6676, in get_slice_bound\n", + " label = self._maybe_cast_slice_bound(label, side)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/core/indexes/base.py\", line 6623, in _maybe_cast_slice_bound\n", + " raise self._invalid_indexer(\"slice\", label)\n", + "TypeError: cannot do slice indexing on Index with these indexers [1] of type int\n", + "\n", + "During handling of the above exception, another exception occurred:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2057, in showtraceback\n", + " stb = self.InteractiveTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1288, in structured_traceback\n", + " return FormattedTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1177, in structured_traceback\n", + " return VerboseTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1030, in structured_traceback\n", + " formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 935, in format_exception_as_a_whole\n", + " self.get_records(etb, number_of_lines_of_context, tb_offset) if etb else []\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 987, in get_records\n", + " style = stack_data.style_with_executing_node(style, self._tb_highlight)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/stack_data/core.py\", line 455, in style_with_executing_node\n", + " class NewStyle(style):\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 91, in __new__\n", + " ndef[4] = colorformat(styledef[3:])\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 58, in colorformat\n", + " assert False, \"wrong color format %r\" % text\n", + "AssertionError: wrong color format 'ansiyellow'\n" + ] + } + ], + "source": [ + "print(surveys_df.iloc[0:4, 1:4])\n", + "surveys_df.loc[0:4, 1:4] " + ] + }, + { + "cell_type": "markdown", + "id": "7b12cdaf", + "metadata": {}, + "source": [ + "### Exercise 5\n", + "- Create a new DataFrame that only contains observations from the original with sex values that are not female or male. Print the number of rows in this new DataFrame. Verify the result by comparing the number of rows in the new DataFrame with the number of rows in the surveys DataFrame where sex is NaN (hint: there is a function `isnull`)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "53f7777a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of rows: 2511\n", + "Unique values in column 'sex': [nan]\n" + ] + } + ], + "source": [ + "df = surveys_df[(surveys_df['sex'] != 'M') & (surveys_df['sex'] != 'F')]\n", + "print(\"Number of rows not female or male:\", len(df))\n", + "print(\"Number of rows NaN:\", len(surveys_df['sex'].isnull()))\n", + "print(\"Unique values in column 'sex':\", df['sex'].unique())" + ] + }, + { + "cell_type": "markdown", + "id": "b34b321b", + "metadata": {}, + "source": [ + "### Exercise 6: Putting it all together \n", + "1. Clean the column *sex* (leave out samples of which we do not know whether they are male or female) and save the result as a new dataframe `clean_df`.\n", + "2. Fill undefined *weight* values with the mean of all valid weights in `surveys_df`.\n", + "3. Calculate the average weight of that new DataFrame `clean_df`" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "570cbd6c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average weight of surveys_df: 42.672428212991356\n", + "Average weight of clean_df: 42.60316325896464\n" + ] + } + ], + "source": [ + "# Step 1\n", + "# sex is 'F' or 'M'. The `|` means or.\n", + "clean_df = surveys_df[(surveys_df['sex']=='F') | (surveys_df['sex']=='M')]\n", + "# Alternative solution: select columns where 'not' sex is null. The `~` means not.\n", + "clean_df = surveys_df[~(surveys_df['sex'].isnull())]\n", + "\n", + "# Step 2\n", + "clean_df.weight.fillna(surveys_df.weight.mean())\n", + "\n", + "# Step 3\n", + "print(\"Average weight of surveys_df:\", surveys_df.weight.mean())\n", + "print(\"Average weight of clean_df:\", clean_df.weight.mean())" + ] + }, + { + "cell_type": "markdown", + "id": "ccb33c2e", + "metadata": {}, + "source": [ + "### Exercise 7\n", + "Let's see in which plots animals get more food. Calculate the average weight per plot! Complete the code below." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "733aba46", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "plot_id\n", + "1 51.822911\n", + "2 52.251688\n", + "3 32.654386\n", + "4 47.928189\n", + "5 40.947802\n", + "6 36.738893\n", + "7 20.663009\n", + "8 47.758001\n", + "9 51.432358\n", + "10 18.541219\n", + "11 43.451757\n", + "12 49.496169\n", + "13 40.445660\n", + "14 46.277199\n", + "15 27.042578\n", + "16 24.585417\n", + "17 47.889593\n", + "18 40.005922\n", + "19 21.105166\n", + "20 48.665303\n", + "21 24.627794\n", + "22 54.146379\n", + "23 19.634146\n", + "24 43.679167\n", + "Name: weight, dtype: float64" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_data = surveys_df.groupby(\"plot_id\")\n", + "grouped_data['weight'].mean()" + ] + }, + { + "cell_type": "markdown", + "id": "2bccb9da", + "metadata": {}, + "source": [ + "### Exercise 8\n", + "See below a more complex grouping example. Investigate the group keys and row indexes for this more complex grouping example. \n", + "Why are there more than 48 groups? Answer: nan values are not ignored when grouping.\n", + "Calculate the average weight per group.\n", + "What happened to the third group and why does it not turn up in our statistics? Answer: the third group contains only nan values and is therefore not included in the statistics." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ee674ae9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "72\n" + ] + }, + { + "data": { + "text/plain": [ + "dict_keys([('F', 1), ('F', 2), ('F', 3), ('F', 4), ('F', 5), ('F', 6), ('F', 7), ('F', 8), ('F', 9), ('F', 10), ('F', 11), ('F', 12), ('F', 13), ('F', 14), ('F', 15), ('F', 16), ('F', 17), ('F', 18), ('F', 19), ('F', 20), ('F', 21), ('F', 22), ('F', 23), ('F', 24), ('M', 1), ('M', 2), ('M', 3), ('M', 4), ('M', 5), ('M', 6), ('M', 7), ('M', 8), ('M', 9), ('M', 10), ('M', 11), ('M', 12), ('M', 13), ('M', 14), ('M', 15), ('M', 16), ('M', 17), ('M', 18), ('M', 19), ('M', 20), ('M', 21), ('M', 22), ('M', 23), ('M', 24), (nan, 1), (nan, 2), (nan, 3), (nan, 4), (nan, 5), (nan, 6), (nan, 7), (nan, 8), (nan, 9), (nan, 10), (nan, 11), (nan, 12), (nan, 13), (nan, 14), (nan, 15), (nan, 16), (nan, 17), (nan, 18), (nan, 19), (nan, 20), (nan, 21), (nan, 22), (nan, 23), (nan, 24)])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_data = surveys_df.groupby(['sex', 'plot_id'])\n", + "print(len(grouped_data.groups))\n", + "grouped_data.groups.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3d9b5ba0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "sex plot_id\n", + "F 1 46.311138\n", + " 2 52.561845\n", + " 3 31.215349\n", + " 4 46.818824\n", + " 5 40.974806\n", + " 6 36.352288\n", + " 7 20.006135\n", + " 8 45.623011\n", + " 9 53.618469\n", + " 10 17.094203\n", + " 11 43.515075\n", + " 12 49.831731\n", + " 13 40.524590\n", + " 14 47.355491\n", + " 15 26.670236\n", + " 16 25.810427\n", + " 17 48.176201\n", + " 18 36.963514\n", + " 19 21.978599\n", + " 20 52.624406\n", + " 21 25.974832\n", + " 22 53.647059\n", + " 23 20.564417\n", + " 24 47.914405\n", + "M 1 55.950560\n", + " 2 51.391382\n", + " 3 34.163241\n", + " 4 48.888119\n", + " 5 40.708551\n", + " 6 36.867388\n", + " 7 21.194719\n", + " 8 49.641372\n", + " 9 49.519309\n", + " 10 19.971223\n", + " 11 43.366197\n", + " 12 48.909710\n", + " 13 40.097754\n", + " 14 45.159378\n", + " 15 27.523691\n", + " 16 23.811321\n", + " 17 47.558853\n", + " 18 43.546952\n", + " 19 20.306878\n", + " 20 44.197279\n", + " 21 22.772622\n", + " 22 54.572531\n", + " 23 18.941463\n", + " 24 39.321503\n", + "Name: weight, dtype: float64" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_data['weight'].mean()" + ] + }, + { + "cell_type": "markdown", + "id": "2336ac85", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "id": "b0f1ab75", + "metadata": {}, + "source": [ + "### Exercise 9\n", + "Would it make sense to group our data frame by the column *weight*? Why or why not?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bbff11b3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of rows: 35549\n", + "256\n", + "255\n" + ] + } + ], + "source": [ + "# In real life nearly every sample has a unique value. So nearly every sample would \n", + "# be placed in an own group.\n", + "# In our training data you can see that there are quite some values for weight. So\n", + "# usually it is not a good idea to categorise (group) data on such values.\n", + "print(\"Number of rows:\", len(surveys_df))\n", + "print(len(surveys_df['weight'].unique())) #includes nan\n", + "print(len(surveys_df.groupby(['weight']).groups)) #does not include nan" + ] + }, + { + "cell_type": "markdown", + "id": "79ae54cf", + "metadata": {}, + "source": [ + "### Exercise 10\n", + "In the given example of vertical concatenation, you concatenated two DataFrames with the same columns. What would happen if the two DataFrames to concatenate have different column number and names?\n", + "\n", + " 1. Create a new DataFrame using the last 10 rows of the species DataFrame (`species_df`);\n", + " 2. Concatenate vertically `surveys_df_sub_first10` and your just created DataFrame;\n", + " 3. Print the concatenated DataFrame info on the screen. How may rows does it have? What happened to the columns? Explain why you get this result." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "18b13126", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unexpected exception formatting exception. Falling back to standard exception\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3460, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"/tmp/ipykernel_16478/1143081575.py\", line 1, in \n", + " species_df = pd.read_csv(\"../data/species.csv\")\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/util/_decorators.py\", line 211, in wrapper\n", + " return func(*args, **kwargs)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/util/_decorators.py\", line 331, in wrapper\n", + " return func(*args, **kwargs)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/io/parsers/readers.py\", line 950, in read_csv\n", + " return _read(filepath_or_buffer, kwds)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/io/parsers/readers.py\", line 605, in _read\n", + " parser = TextFileReader(filepath_or_buffer, **kwds)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/io/parsers/readers.py\", line 1442, in __init__\n", + " self._engine = self._make_engine(f, self.engine)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/io/parsers/readers.py\", line 1735, in _make_engine\n", + " self.handles = get_handle(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/pandas/io/common.py\", line 856, in get_handle\n", + " handle = open(\n", + "FileNotFoundError: [Errno 2] No such file or directory: '../data/species.csv'\n", + "\n", + "During handling of the above exception, another exception occurred:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2057, in showtraceback\n", + " stb = self.InteractiveTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1288, in structured_traceback\n", + " return FormattedTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1177, in structured_traceback\n", + " return VerboseTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1030, in structured_traceback\n", + " formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 935, in format_exception_as_a_whole\n", + " self.get_records(etb, number_of_lines_of_context, tb_offset) if etb else []\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 987, in get_records\n", + " style = stack_data.style_with_executing_node(style, self._tb_highlight)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/stack_data/core.py\", line 455, in style_with_executing_node\n", + " class NewStyle(style):\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 91, in __new__\n", + " ndef[4] = colorformat(styledef[3:])\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 58, in colorformat\n", + " assert False, \"wrong color format %r\" % text\n", + "AssertionError: wrong color format 'ansiyellow'\n" + ] + } + ], + "source": [ + "species_df = pd.read_csv(\"../../course_materials/data/species.csv\")\n", + "species_df_sub_last10 = species_df.tail(10)\n", + "\n", + "surveys_df_sub_first10 = surveys_df.head(10)\n", + "vert_concat = pd.concat([surveys_df_sub_first10, species_df_sub_last10], axis=0)\n", + "\n", + "vert_concat" + ] + }, + { + "cell_type": "markdown", + "id": "aa6d4ee8", + "metadata": {}, + "source": [ + "We get a total of 20 rows and 12 columns. The original dataframes together had a total of 13 columns. As they both have a column `species_id`, this one is collapsed. All other columns are padded with `NaN` values.\n", + "We expect 20 rows, as we are putting two DataFrames of 10 rows one after the other. The padding of the columns happens because these two DataFrames do not have the same column names. To keep all the information that was in the original DataFrames, the padding of columns that occur in only one of the two is necessary." + ] + }, + { + "cell_type": "markdown", + "id": "9478026d", + "metadata": {}, + "source": [ + "### Exercise 11\n", + "In the given example of horizontal concatenation, you first concatenated two DataFrame with different indices, then reset the indices of the second one. Based on the outcome of these two cases, try to answer the following questions:\n", + " 1. What happens when you concatenate horizontally two DataFrames with different indexing?\n", + " 2. What happens when you concatenate horizontally two DataFrames with the same columns?\n", + " 3. What happens when you try to select a column of the `horizontal_stack` DataFrame we just created?\n", + " 4. How can you select a specific column, when multiple columns share a name?" + ] + }, + { + "cell_type": "markdown", + "id": "b5b01c88", + "metadata": {}, + "source": [ + "1. The columns of both DataFrames are kept, duplicates are not merged, and the rows of both DataFrames are kept as well, no merging there either. This results in the two original DataFrames appearing in a checker-pattern in the resulting DataFrames, with the empty spaces padded out with `NaN` values.\n", + "2. Columns still are not merged, but now, rows with a common index are merged. This means that the information of both rows is put into a single row in the resulting DataFrame. If no corresponding row exists in the other DataFrame, the row is still padded with `NaN`'s in the result. But if a corresponding row (with the same index) *does* exists, this is no longer necessary." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0faee1fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unexpected exception formatting exception. Falling back to standard exception\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3460, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"/tmp/ipykernel_16478/3936511566.py\", line 4, in \n", + " horizontal_stack = pd.concat([surveys_df_sub_first10, surveys_df_sub_last10], axis=1)\n", + "NameError: name 'surveys_df_sub_first10' is not defined\n", + "\n", + "During handling of the above exception, another exception occurred:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2057, in showtraceback\n", + " stb = self.InteractiveTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1288, in structured_traceback\n", + " return FormattedTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1177, in structured_traceback\n", + " return VerboseTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1030, in structured_traceback\n", + " formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 935, in format_exception_as_a_whole\n", + " self.get_records(etb, number_of_lines_of_context, tb_offset) if etb else []\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 987, in get_records\n", + " style = stack_data.style_with_executing_node(style, self._tb_highlight)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/stack_data/core.py\", line 455, in style_with_executing_node\n", + " class NewStyle(style):\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 91, in __new__\n", + " ndef[4] = colorformat(styledef[3:])\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 58, in colorformat\n", + " assert False, \"wrong color format %r\" % text\n", + "AssertionError: wrong color format 'ansiyellow'\n" + ] + } + ], + "source": [ + "# 3.\n", + "surveys_df_sub_last10 = surveys_df.tail(10)\n", + "surveys_df_sub_last10 = surveys_df_sub_last10.reset_index(drop=True)\n", + "horizontal_stack = pd.concat([surveys_df_sub_first10, surveys_df_sub_last10], axis=1)\n", + "horizontal_stack['species_id']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4f860304", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unexpected exception formatting exception. Falling back to standard exception\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3460, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"/tmp/ipykernel_16478/4095435365.py\", line 2, in \n", + " horizontal_stack.iloc[:,5]\n", + "NameError: name 'horizontal_stack' is not defined\n", + "\n", + "During handling of the above exception, another exception occurred:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2057, in showtraceback\n", + " stb = self.InteractiveTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1288, in structured_traceback\n", + " return FormattedTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1177, in structured_traceback\n", + " return VerboseTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1030, in structured_traceback\n", + " formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 935, in format_exception_as_a_whole\n", + " self.get_records(etb, number_of_lines_of_context, tb_offset) if etb else []\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 987, in get_records\n", + " style = stack_data.style_with_executing_node(style, self._tb_highlight)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/stack_data/core.py\", line 455, in style_with_executing_node\n", + " class NewStyle(style):\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 91, in __new__\n", + " ndef[4] = colorformat(styledef[3:])\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 58, in colorformat\n", + " assert False, \"wrong color format %r\" % text\n", + "AssertionError: wrong color format 'ansiyellow'\n" + ] + } + ], + "source": [ + "# 4.\n", + "horizontal_stack.iloc[:,5]" + ] + }, + { + "cell_type": "markdown", + "id": "d6382b5f-9c13-4ceb-88f6-f7ba13f797f7", + "metadata": { + "tags": [] + }, + "source": [ + "### Exercise 12\n", + "Time to play with plots! Look at the pandas.DataFrame.plot() documentation [here](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.html) and change your data visualization swapping the DataFrame columns, and changing the axes labels.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1896c89b-f2c2-41ae-9a18-9b9fb8a87648", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Scatter plot of weight versus hindfoot length')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax1 = plt.subplots() # prepare a matplotlib figure\n", + "\n", + "surveys_df.plot(\"hindfoot_length\", \"weight\", kind=\"scatter\", ax=ax1)\n", + "\n", + "# Provide further adaptations with matplotlib:\n", + "ax1.set_xlabel(\"Hindfoot length\")\n", + "ax1.tick_params(labelsize=16, pad=8)\n", + "fig.suptitle('Scatter plot of weight versus hindfoot length', fontsize=15)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "339fb652", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Scatter plot of hindfood length versus weight')" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHtCAYAAAD4G2HhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAACTjklEQVR4nO3dd3hUZdoG8Puk954AgRRCQlCKJoYIhCogiIoCogaVIn6KBVRgFcRddS2sBRv2XRRBBUUBcS1LkZIASksQlJ4EQjO9Q0h5vz/iDFPO1Eyf+3dduSCnvufMmZkn5zzv+0hCCAEiIiIiN+Zh7wYQERER2RsDIiIiInJ7DIiIiIjI7TEgIiIiIrfHgIiIiIjcHgMiIiIicnsMiIiIiMjtMSAiIiIit8eAiIiIiNweAyIL2Lx5MyZMmIDOnTvDx8cH4eHhSE1NxcSJE/HOO++gurra3k10SYmJiZAkyd7NMMuGDRswcOBABAcHQ5Iko47DnOOdOnUqJEnCli1bzGypcYqKiiBJEoYOHao1r7S0FJMnT0anTp3g6ekJSZKwdOlSq7bHFJIkITEx0ejlbXVObenZZ591uNeFrGvLli2QJAlTp051qG3ZEwOidvrnP/+J6667DqtXr0ZoaChuuukmXH/99fD398fq1asxc+ZMHDp0yKZtMvSBzQ8/dUuXLoUkSXj22Wdtsr9Tp05h3Lhx2LVrFwYNGoQpU6ZgypQpNtm3PUyfPh3Lly9HTEwMsrOzMWXKFCQnJ9u7WW7FFYM4cm76/oiyFy97N8CZ7d27F88++yy8vb3x1Vdf4dZbb1Wbf/78eXz22WcICwuzS/vIMW3cuBH19fX4+9//jn/+859W3dfChQsxb948xMfHW3U/uly6dAk//PADEhMTkZeXBw8P/g1G5AgyMzNx6NAhhIaG2rspDoMBUTusXr0aQgjcfvvtWsEQAHTs2BFz5861fcPIoZ0+fRoAkJSUZPV9derUCZ06dbL6fnQ5f/48WlpakJCQwGCIyIEEBASgR48e9m6GQ+EnVDuUlpYCAKKjo01et76+Hi+//DIyMjIQEhKCwMBA9OjRAw8//DCOHj2qXO7ixYtYsmQJbrnlFiQlJcHf3x9hYWEYPHgwVq5cqbVdSZLw6aefAgCGDRumzE+RJAlFRUVITEzEc889BwCYNm2a2nzN2+m//vorJk6ciE6dOsHHxwddunTBfffdh1OnTmntV/Ux3K5du3DTTTchMjISkiQhPz9f77lQff587tw5TJ06FR06dIC/vz/S09OxbNkyE88usHPnTtxyyy2Ijo6Gr68vEhMT8dBDD+Hs2bNqyw0dOhTTpk0DADz33HNq58PYR4oNDQ14/vnn0atXL/j7+yM0NFT29VEc5zPPPANA/fyb+rjuP//5D/r06QN/f3907NgRDzzwAKqqqrSW0/WoRDUfydhtAUBxcTHuueceREdHIyAgANdccw0+++wz2WUTExORkJAAANi6davyWDXzdYx9rVQtX74cAwcOREhICAICAtCnTx8sXLgQFy9elF2+oqICjzzyCGJjY+Hn54crr7wSb731FoQQOvdhjoaGBixcuBBpaWkICgpCUFAQ+vXrp3xPalKcj5aWFrz88svo3r07fH19ERcXhyeffBKNjY2y6/3222+4+eabERYWhuDgYAwePBgbNmyQzeUw9Jmg6cCBAxg7dizCw8MRGBiIIUOGYMeOHUafgz59+kCSJBw+fFh2fnl5OXx8fNChQwc0NzerzbP0Z05paSnmzZuHK6+8EkFBQQgNDUX37t0xefJk7Nq1S7ktQ49vdKUZGLt9XXTl3rS2tiIiIgKSJOHpp59Wm1ddXQ0vLy/06tVLa3uHDh3C1KlTERcXB19fX3To0AF33nknfv/9d6P3DbR9P82bNw+JiYnw8/NDcnIynn/+eTQ1NRnMZayoqMCDDz6ITp06wdfXF7169cLHH3+stsyzzz6Lrl27AlD/bLB3HhLvELVDXFwcAOCbb77B/PnzERMTY9R6586dw8iRI/H7778jPDwcQ4cOha+vLwoKCvDBBx8gJSUF3bt3B9D2Rr3vvvsQGxuL1NRUZGZm4vz589ixYwdycnJw+PBhtS/TKVOmIDc3FydOnMCoUaPQsWNH5bygoCDcdttt2LhxI/bv34+srCy1XA7VZd977z3MnDkTANC3b18MGjQIR44cwZIlS7Bu3Tps3boVV1xxhdaxbdu2Dffffz+6d++O66+/HmfPnjX6zkBFRQX69euHxsZGDB06FJWVldi8eTOmTJmCgoICo4OGzz77DFOnTkVLSwuysrIQFxeHffv24f3338fq1auxZcsW5V9Go0ePRnNzM7Zv346rrroKV199tXI7xuS51NbWYtiwYdi7dy+io6Nx0003ob6+Hj///DNycnKwc+dOvPXWWwDazu+UKVOQn5+vdf5V92vIE088gbfeegtDhw5FcnIytm/fjo8++giHDh1SfrhYY1uFhYUYMGAAzp8/j6SkJIwYMQJnzpzB5MmT8fDDD2tt+7bbbkNRURG++eYbdOjQAaNHjwYAREVFKZcx5bVSeOCBB/DRRx/Bz88P1113HQICArBlyxY89dRT+O6777Bx40YEBAQol6+srMTAgQNx6NAhdOzYEbfccgsqKiowd+5cHD9+3OhzZUhJSQlGjhyJ3377DR07dsSQIUMghMCOHTswdepU7NmzB4sXL5Zdd9KkSfjhhx8wdOhQpKamIicnB6+88grOnDmjFXDu3LkTI0aMQENDA/r06YMrr7wSJ06cwOjRo2VfB0OfCar27NmDhx9+GN26dcOoUaNw+PBhbNu2DcOHD8fu3btlv4Q13XXXXZg3bx4+//xzPP/881rzV61ahaamJtxxxx3w8rr8FWTpz5za2lpce+21KCwsRFxcHEaOHAkvLy+cOnUKK1euRFJSEjIzMw0ejy6W2H6/fv3g6+ur9QfL/v37UVlZCQBa87Zt24aWlhat4G3t2rW488470djYiKuvvhr9+vVDcXExvvrqK3z33Xf48ccfMXjwYIPH1djYiBEjRuCXX35BREQEbrrpJjQ2NuJf//oX9u3bp3fdqqoq9O/fH3V1dRg0aBDKysqwbds2TJ8+Ha2trbjvvvsAtH3eTZgwQeuzAQAGDhxosI1WI8hsJ06cEP7+/gKACA4OFlOmTBH//ve/xb59+0Rzc7PO9YYPHy4AiNtvv13U1taqzSssLBT79+9X/l5WViY2bNggWltb1ZYrKCgQiYmJwsPDQxQWFqrNmzJligAgNm/eLLv/Z555RgAQn3zyiez8nTt3Ck9PT9G5c2exZ88etXn/+c9/BABx7bXXym4TgHj55Zd1HruczZs3K9cdOXKkqKurU87btWuXCAoKEh4eHmLv3r1q6yUkJAjNS/jUqVPC399feHp6im+//VY5vaWlRTz22GMCgMjIyFBb55NPPhEAxDPPPGNSu4UQ4pFHHhEAxLBhw0RNTY1y+qFDh0RMTIwAIL777ju1dQydf10Ux9uxY0dx+PBh5fTS0lKRnJwsAIhNmzapraPrWjBnW6NHjxYAxL333iuampqU09etWyc8PT0FADFkyBC1dQoLC2WnC2Hea/X1118LACI2NlYcPXpUOb2qqkoMHDhQABBz5sxRW2fGjBkCgBg9erSor69XTv/1119FUFCQACASEhK02qeLrnM6ZswYAUA8+uij4uLFi8rp58+fFxkZGQKA+PHHH9XWUVz3V1xxhTh37pxyekFBgQgLCxMAxPHjx9XOTffu3QUA8eKLL6ptS/HeBCCmTJliVJsVVN+/b731lto8xWtxzz33GDo1Qoi211WSJNGtWzfZ+YrX6ZdfflFOs8ZnzscffywAiLFjx4qWlha1eSUlJeLAgQPK3/Vdp6r7Un3PmrJ9fQYPHiwAqH2Ov/766wKA6Nmzp/Dx8VG7bmfPni0AiFWrVqm1PzAwUAQFBYkNGzaobf/HH38U3t7eIi4uTjQ2NiqnKz53Na+V559/XgAQmZmZorKyUm0fcXFxynOuSvUz/M4771S7/tesWSMAiPj4eLV1DJ1ze2BA1E4bN25Uu0gUP2FhYeLBBx8UZ8+eVVv+119/FQBETEyM2heoOf79738LAOLtt99Wm97egOiWW26R/SJXGDt2rAAg9u3bp7XN3r17awVvhijeTB4eHmpfzgpPPvmkACCmT5+uNl0uIPrHP/4hAIjs7Gyt7Vy8eFHExsYKACI3N1c53dyAqK6uTvj7+wsPDw9x6NAhrflvv/22ACBGjBihNr29AdG///1vrXmvvfaa7DEYCoiM3daJEycEABESEiKqqqq01rnjjjtMDojMea0UXx4ffvih1jr79+8XkiSJoKAgceHCBSGE+mukGlgoKK6t9gZEeXl5AoDo27ev1pejEELs27dP+eWpSvF5ofklJsTlYFv1OtmwYYMAIFJSUmT3k5WV1a6AKCsrS2teWVmZyedoyJAhAoDYuXOn2vSioiIhSZJITk5Wm26Nz5yXX35ZABBvvvmmwfaaExCZsn19FO8D1W2PHTtWBAcHK4NB1esjPT1dABAlJSXKaY8++qgAIBYvXiy7j1mzZgkAYvXq1cppugKizp07CwAiJydHazuK7xxdAVFISIgoKyvTWq9Xr15aQZ8jBkTMIWqn4cOH4/jx41i9ejVmzJiB9PR0eHl5oaqqCu+//z6uvvpqHDlyRLn8xo0bAQDZ2dkIDg42ej+5ubl44YUX8OCDD2LatGmYOnUqVq1aBQA4duyYxY6ntbUVmzZtQkBAAEaNGiW7zKBBgwBA9hn5TTfdZPbYQFdffTVSU1O1pmdnZwMAcnJyDG5Dscxdd92lNc/X1xcTJ040eluG7N27FxcuXEB6erpscuI999wDANi+fTtaW1vbvT+F66+/Xmua4hHruXPnrLKt3NxcAG2PGOV6pSheI1OY+lo1NTXhl19+0blOnz590KdPH9TV1SlzSBSvUUZGBrp162aRdstZv349AODWW2+VfUSsyCmSe894e3tj2LBhWtPlXoft27cDACZMmCC7nzvuuMO8A/iL3PUQGRmJiIgIk64txevzxRdfqE3/4osvIIRQe/2s9ZlzzTXXAABeffVVrFy5ErW1tUa33xiW2v6QIUMAXH401traipycHAwcOBDDhw9Xm1ddXY38/HxceeWVarmriutv/PjxsvvQd/5UnTx5EmfOnEHHjh1lH10Zur6uueYaREZGak039/PJ1phDZAE+Pj4YN24cxo0bB6DtOerKlSvx1FNPoaSkBI888gg2bNgAoC0pFYDsh7Oc6upqjB8/Hj///LPOZSz5Ri8rK0NdXR2AtuMytKym9nTvViTgalIk4epLslVQLKNroD3F9DNnzpjcPlP3FRYWhtDQUFRXV6OyslL2g8IcXbp00ZqmCK51JeG2d1uKYzX0GpnC1NeqvLwcly5dQlRUFAIDA3Wus3//fuU61mi3HEVy8oIFC7BgwQKdy8klfXfs2BGenp5a0+VeB8UXiiJ/UVN7h1eQux4UbamoqDB6O7fddhtmzpyJL7/8Em+88Yby+D7//HMA6gGttT5zhg8fjscffxxvvvkmsrOz4eXlhfT0dIwcORL33ntvu3t5Wmr7/fv3V8sjUuQPDRs2TNkxQTFv27ZtaG1t1cofUlx/nTt31rsvufOnytD1FRwcjLCwMJ2dLvRdP4Dpn0+2xoDICsLCwjBjxgzExsbilltuwebNm9HQ0KCW6GmsJ598Ej///DOGDBmC5557Dr169UJYWBg8PT2xfv16jBo1yqI9ZRR3MoKCgjBhwgS9y/bs2VNrmp+fn8XaYg22HtnaGvuzZPd1R+4Kb865s9fI5Yr3zcCBA43+Y0fBkV4DS7UlPDwcY8aMwZo1a7Bx40aMGjUK+/fvx++//46+ffsiJSVFuaw1P3Nef/11PPDAA/j222+xceNGbN++Hbt27cIrr7yCFStWGNyfZhutsX1/f39kZmYiJycHRUVFyuBHEfQMHToUK1asQENDg3Ke4q6SZvsMDfB67bXXGmxPezjStWwOBkRWdN111wEAWlpaUFVVhYCAAGXkfeLECaO2sWbNGnh6emLdunUICQlRm1dQUGDZBqOtB5Cfnx88PDzwySef2PQL5uTJk3qnx8bGGtxGbGwsjhw5gpMnT8p+eBr7l5QxFO3R1e7q6mpUVVXB398f4eHh7d6fPSnGMjL0GpnC1NcqMjISPj4+KCsrQ319vexdIs11rNFuOYq/jG+99VbMmTPHItuUozgexZ1mTbqm28Ndd92FNWvW4PPPP8eoUaOUd4fuvvtuteWs/ZmTmpqKJ554Ak888QQuXryId955B3/729/w4IMPKgMWxZ0pxZ0qTfrOqzHbN2TIkCHIycnBli1bsGXLFoSEhCA9PR1AW0D06aefYseOHVrBkkKXLl1w4sQJLFq0qF13og1dX7W1tTrvDrkC5w7n7MzQnRlFl14fHx9lV+MRI0YAAFasWKHzzaeqsrISISEhWsEQAHz11Vey6yje3JpjfBgz38vLC0OHDkVNTQ02bdpksH2WlJ+fL5sPpRjPx5jumIpn5StWrNCad+nSJWXelWI5wPD50uWaa66Bv78/9u7dK9tuRXfprKwsp//LSXHuf/rpJ9TU1GjNlxsTyxBTXytvb2/069dP5/4OHjyI/fv3IygoSDmMgeprJPcHhDntljNy5EgAbX/AWFNWVpZyP3KfP+Z+JljDTTfdhNDQUKxduxb19fVYsWIFPD09tfJQbPmZ4+fnh7lz56JTp04oLS1FSUkJgLagzMvLC4WFhVrnqKmpCVu3bm3X9g1RBDiK4ToGDRqkfMyomPftt98iPz8fV1xxhdYQL5a6/hISEtC5c2fl0C6aFO9JS7DHNWmIc39K29nf//53/O1vf5O923PmzBk88MADAICxY8cqX/zMzEwMGzYMJSUluP/++1FfX6+2XlFREQ4cOKD8vXv37qisrMSXX36pttwbb7yBzZs3y7ZLcedCNZnblPkLFiyAh4cHpk2bJlv7qK6uDh9//DEuXLggu765WltbMXPmTDQ0NCin7d27F++88w4kScKDDz5ocBvTp0+Hv78/Vq5cie+//15t20899RTOnDmDa665RvnFAhg+H7oEBgbi3nvvRWtrKx5++GG11/Lo0aN44YUXAACzZs0yabuOqFu3brj++utRU1ODOXPmoKWlRTnvhx9+MOuD0pzXSjFOzbPPPqsW4NTW1uKRRx6BEAIPPPCA8jFKUFAQ7rnnHrS0tGDmzJlq1+yePXvwzjvvmNxuOddeey1GjhyJ7du34+GHH5YNGvfv34+ffvqpXfu57rrrkJKSgiNHjuCVV15Rm7d06VKdnQXMvcbbw9fXF7fddhtqa2sxd+5cnD59GiNGjECHDh20lrXGZ87atWuVSfiq9u7diz///BNBQUHKsko+Pj7o378/Kioq8O677yqXbW5uxpw5c1BYWNiu7RsyYMAA+Pj4YNWqVaisrFS7A6TII/rPf/6D1tZWrcdlADBnzhz4+/tj7ty5WL16tdb8xsZGfP3118pR8vWZMWOGcpuqhclPnjxp0VJDUVFR8Pb2xokTJ9Q+T+zKrn3cnJyiqyMA0b17d3HrrbeKO++8UwwcOFB4e3sLACI5OVmcPn1abb3Tp0+L1NRUAUBERESIsWPHiokTJ4r09HTh4eEh3njjDeWyn332mXIfgwYNEtnZ2eLKK68UHh4e4vHHH5ftNrlnzx4hSZLw8/MTt9xyi5g+fbqYPn26sjvkmTNnhJ+fn/D09BSjR48W9957r5g+fbpal/f3339fObZMr169xPjx48Udd9whrr32WuHr6ysAqI1RYW5XciEud9m86aabRFxcnOjYsaO4/fbbxahRo5Tn8emnn9ZaT67bvRBCLFu2THh4eAhJksTAgQNFdna28nx36NBBq4v8hQsXlGMGDRkyREybNk1Mnz5dbN++3WDba2pqxDXXXKMcSmHixIlizJgxws/PTwAQs2bN0lqnvd3u5ejqQmuo270p2zpx4oTo0KGDACC6desm7rzzTjF48GAhSZJ4+OGHTe52L4Tpr5UQQtx///0CgPD39xc33nijmDhxooiOjhYARL9+/dTGbBFCiPLycuU2O3XqJO644w5x/fXXCy8vL2W7LTEO0Z9//inS0tKUw24MHTpUTJo0Sdx4443KoTkeffRRtXX07VvXcBA7duwQAQEBAoC46qqrRHZ2tsjMzFR7Hf7v//5PbR1DnwmGrkl914s+P//8s9pwJMuXL9e5rKU/cxSfz507dxY33XSTmDRpkhg6dKhyH4sWLVJbfsOGDcLDw0MAEP379xfjxo0T8fHxIioqSvmaq+7L1O0bohgyAYDYvXu32jzF/gGIlStXyq6/du1a5XWRnJwsbr75ZnHnnXeKQYMGicDAQAFA5OXlKZfX9T6/ePGi6NevnwAgIiMjxW233SZuvvlmERgYKMaOHSvi4+OFt7e32jq6tqXZfs33zM033yyAtvGW7rnnHjF9+nTx8ccfG3W+rIEBUTuUlpaK5cuXi7vvvlv07t1bREZGCi8vLxERESGysrLEK6+8ojbIoKqamhrxz3/+U/Tp00f4+/uLoKAg0aNHD/HII4+IY8eOqS37/fffi379+ong4GARFhYmRowYIbZs2aL3Ivz8889Fenq6cuBIaIwB8b///U9kZWUpB6aTu1jz8vLElClTREJCgvDx8RFhYWGiZ8+e4t577xX//e9/1cb+sERANGXKFHHmzBlx9913i+joaOHr6yuuuuoqsz6kt2/fLm6++WYRGRkpvL29RXx8vHjwwQe1glOF3bt3i5EjR4rQ0FAhSZJJx1JXVyeee+45ceWVVwpfX18RHBwsBg4cKL744gvZ5Z01IBKibRyZSZMmicjISOHn5yeuvvpqsXTpUp2BjzFjjZj6WgnRFkgNGDBABAUFCT8/P9GzZ0/x4osvioaGBtnly8rKxIMPPig6duwofH19RY8ePcRrr70mWltbLRYQCdEWXL/99ttiwIABIjQ0VPj4+Ii4uDgxZMgQ8eqrr4ri4mK15c0JiIQQIj8/X9x0000iJCREBAYGiqysLPHjjz8q/4CaN2+e1jr6PhOsFRC1tLSILl26CAAiICBAayBaTZb8zMnLyxNz5swRffv2FTExMcLX11ckJCSIm2++WWzcuFF2nf/+97+ib9++wtfXV0RERIjbb79dFBYWyu7LnO3rs2DBAgFAhIaGag3sq7gWAKgN4Knp+PHj4qGHHhIpKSnCz89PBAcHi9TUVHHnnXeKr776yqiBGYUQora2VjzxxBMiPj5e+Pj4iKSkJPGPf/xDXLhwQfj6+oqOHTuqLW9uQPTnn3+Ke+65R3Ts2FEZSOrahi1IQli4mA+RibZs2YJhw4ZhypQpRtcPIyJtM2bMwIcffoiVK1e2e0wiIk2//PIL+vfvj9GjR+PHH3+0d3MsjjlEREROpKKiQrYo65dffon//Oc/CAsLw0033WT7hpHLyMvL0xpqoKCgQJkXq9lT0FWw2z0RkRM5evQo+vfvjz59+igH/zt06BCOHDkCT09PfPjhhzoHriQyRnZ2Nqqrq9G7d29ERkbi1KlT2Lt3LxobGzF27FhMmjTJ3k20CgZEREROJCkpCQ8//DB+/vlnbN68GfX19YiKisL48eMxd+5c9O/f395NJCc3c+ZMfPXVV/jtt99QUVEBPz8/XH311bj77rsxY8YMuw2Aam3MISIiIiK3xxwiIiIicnsMiIiIiMjtMSAiIiIit8eAiIiIiNweAyIiIiJyewyIiIiIyO0xICIiIiK3x4CIiIiI3B4DIiIiInJ7DIiIiIjI7TEgIiIiIrfHgIiIiIjcHgMiIiIicnsMiIiIiMjtMSAiIiIit8eAiIiIiNweAyIiIiJyewyIiIiIyO0xICIiIiK3x4CIiIiI3B4DIiIiInJ7DIiIiIjI7TEgIiIiIrfHgIiIiIjcHgMiIiIicnsMiIiIiMjtedm7Ac6gtbUVZ8+eRXBwMCRJsndziIiIyAhCCNTW1iI2NhYeHvrvATEgMsLZs2cRFxdn72YQERGRGYqLi9GlSxe9yzAgMkJwcDCAthMaEhJi59YQERGRMWpqahAXF6f8HteHAZERFI/JQkJCGBARERE5GWPSXZhUTURERG6PARERERG5PQZERERE5PYYEBEREZHbY0BEREREbo8BEREREbk9BkRERETk9hgQERERkdtjQERERERujwERERERuT2W7iCLKCitw8mKBiRGBqJrVKC9m0NERGQSBkTULlUNlzBrRT62HStVThucEo3F2WkIDfC2Y8uIiIiMx0dm1C6zVuRj+/EytWnbj5dh5oo8O7WIiIjIdAyIyGwFpXXYdqwULUKoTW8RAtuOlaKwrN5OLSMiIjINAyIy28mKBr3zi8oZEBERkXNgQERmS4gI0Ds/MZLJ1URE5BwYEJHZkqKDMDglGp6SpDbdU5IwOCWavc2IiMhpMCCidlmcnYas5Ci1aVnJUVicnWanFhEREZmO3e6pXUIDvLFseiYKy+pRVF7PcYiIiMgpMSAii+gaxUCIiIicFx+ZERERkdtjQERERERujwERERERuT0GREREROT2GBARERGR22NARERERG6PARERERG5PYcJiC5duoS3334bAwcOREREBPz8/NClSxfccMMN+PLLL2XX2bhxI8aMGYOoqCj4+/ujR48eWLBgAerq6mzceiIiInJmDjEw4+nTpzFq1Cj88ccfiIqKQlZWFgIDA1FcXIxt27YhMDAQd9xxh9o6b7zxBmbPng1JkjBo0CB06NABOTk5eOmll/DNN98gNzcXUVFROvZIREREdJndA6ILFy5g5MiROHz4MJ599lk89dRT8Pb2Vs5vaGjA0aNH1dbJy8vDnDlz4Onpie+++w433HCDctmxY8di06ZNmDFjBr7++mubHgsRERE5J7s/Mlu4cCEOHz6M+++/H88884xaMAQAAQEBuPrqq7XWEUJg2rRpymBIseySJUvg4eGBb775BocPH7bFIRAREZGTs2tA1NTUhPfffx8A8Le//c2odS5duoTvv/8eADBp0iSt+QkJCcjKygIArFmzxkItJSIiIldm10dm+/btQ1lZGWJjY5GcnIwDBw5g9erVOHv2LMLDwzFo0CDccMMN8PC4HLcdPXoUDQ0NAICMjAzZ7WZkZCAnJwd5eXk2OQ4iIiJybnYNiH777TcAQJcuXTBv3jy88sorEEIo57/88stIS0vD2rVrER8fDwAoLCwEAISFhSE4OFh2u3FxcWrLEhEREelj10dm5eXlANqSpF9++WU89NBDOHLkCKqrq7FhwwZ0794deXl5uPHGG9HU1AQAqK2tBQAEBgbq3G5QUBAAoKamxqx2NTY2oqamRu2HiIiIXJddAyLF3aCmpiZkZ2fjnXfeQffu3RESEoIRI0Zgw4YN8PPzw8GDB7Fy5UqbtWvhwoUIDQ1V/ijuOBEREZFrsmtApPrI64EHHtCaHx8fjxtvvBFA2yCMquvU19fr3K5iYMaQkBCz2jV//nxUV1crf4qLi83aDhERETkHu+YQJSUlyf5fbplz584BABITEwEAVVVVqK2tlc0jUgQwimVN5evrC19fX7PWJSIiIudj1ztE6enpkCQJAFBWVia7jGK6Ii8oNTUVAQEBAIA9e/bIrqOYnp6ebtH2EhERkWuya0DUsWNHDBw4EMDlR2KqmpqasHXrVgBAZmYmAMDHx0f5GO2LL77QWufkyZPYsWMHAGDcuHFWaTcRERG5FruPVP3MM88AaEtk/uWXX5TTm5ubMWfOHBQUFCA4OBjTpk1Tzps3bx4kScInn3yCn376STm9oaEB06dPR0tLCyZMmIAePXrY7kCIiIjIaUlCdeAfO3nhhRfw97//HV5eXsjMzETHjh2xb98+FBUVwd/fH6tWrVLeFVJQLe46ZMgQxMTEICcnB+fOnUNqaqpFi7vW1NQgNDQU1dXVZidqExERkW2Z8v3tEAERAKxfvx5vvvkmfv31V9TW1qJjx44YPnw4nnzySZ13ejZu3IhFixZh165dqK+vR3x8PG677TbMnz9f56CN5mBA5DgKSutwsqIBiZGB6Bqleywqci58XYnIGpwyIHJkDIjsr6rhEmatyMe2Y6XKaYNTorE4Ow2hAd561iRHxteViKzJlO9vu+cQERlj1op8bD+u3hNx+/EyzFzBenXOjK8rETkKBkTk8ApK67DtWClaNG5mtgiBbcdKUVime5BOclx8XYnIkTAgIod3sqJB7/yicn5xOiO+rkTkSBgQkcNLiAjQOz8xkkm4zoivKxE5EgZE5PCSooMwOCUann+Naq7gKUkYnBLNXklOytqva0FpHTYfKbHrozdHaAMRGYe9zIzAXmb2V93QhJkr8tgbycVY43V1hJ5rjtAGImK3e4tjQOQ4CsvqUVRez/FqXIwlX9fJS3Zh+/EytWRtT0lCVnIUlk3PbG9TnaYNRGTa97ddq90TmaprFAMhV2Sp11XRc02Tas81a18/jtAGIjIdc4iIyGU4Qs81R2gDEZmOd4iIyGW0p+eapcqHsPcckXNiQERELkPRc01X/o5coGPpBGhz2kBE9sdHZkTkUhZnpyErOUptWlZyFBZnp8kub43yIaa2gYjsj73MjMBeZkTOx5ieawWldbhu0Vad29g8d2i77uiwVySRfbGXGRG5PWN6rhmTAN2eQIa9IomcBwMiIgJguaRiazCnbfrWUczTHCVbk2oCtLFtKCitw6+FFZAAXJsUqffulCWPiYjahwERkZtz5FGVzWmbvnUEhNY8XcIDvBER4GN0G6oaLuHBz/ZhZ0G52nYGdIvE+3ddo1zW0sdk79eIyFUwh8gIzCEiV+bIoyqb0zZ96wDQmqeLB4CBKdGy68i1YfKSXToDrcEp0cplLX1M9n6NiBwZc4iIyCiOPKqyOW0ztI4pWgGd62i2Qdd+FRTLCh3taM8xceRrIstgt3siN+bIoyqb0zZD61iaog3G7LeovN4qx8SRr4ksg3eIiNyYI4+qbE7bDK1jaYo2GLPfxMhAGMpQMOeYOPI1kWUwICJyE6o9q85UNQCQ0C8p0qhRlbceKUH+6Sqkx4ejtVUo/985zF/Z60kIYXQvLGN7SvWKDcEfZ2vQqjJNApASE6i8M9I1KhBf7jqFnYXluNjYjFB/L1RfaFbbjqck4YrYYFTUXcLZ6otGn7PEyAB4e3rgeEkdNEOZIF9PfP7LSWSlRMFTAlJignCspE52O707h2Dd/jNIjw9HRkI49p2sVDsm1fOten4U57RvQjj2napSe40UOU6a6/DxGZF5mFRtBCZVkzOT66Gkqm9COLy9PLDjxOXeUYoeTFUXLuHWd7ejsqHJpH3q6oVlbG8tY3uCGcvTA2hpNbycvYQHeOOz6Zl4+aejOo9bLtDLTIyAp4ek1rONvc+ILjPl+5sBkREYEJEzk+uhpGlwSjSeu6Wn1qjKaf9cb3IwBOjuhWVsby1je4K5Ck9JQoi/F2ouNLf7uNn7jOgyU76/mVRN5MIUPZQMfckq7koMS41Re0xmTjAEqPeA0tcOY5dzdS1CoLKhySLHrXlOicg4DIiIXJgpva40eyvln65q9/6N7YVlSm8tMg57nxGZhknV5DCYGGoaufOlmvw8KCUaJSYlEAeqbbdjiF+723i++iIKy+oNtuPLXacAACU1xreX9GPvMyLTMCAiu2NZAtPIna++ieE4+mcdqi+Y94hrcEo0wgO8tUZb9vKQ0Nxq/mOc+asPGLXcT7//iZ9+/9Ps/dBlmj0Eicg4fGRGdjdrRT62Hy9Tm7b9eBlmrsizU4scm9z52l1UaXYw1D8pEouz02S3255giCwr1N8LA7pFGlwuKzkKi7PTbNAiItfCO0RkVyxLYBpDJSKM8cSoVEQE+kAA6PdXNXZztnvfwET8J7eoXW0h41VfaMaMId3UhkfQtHx6Jgb9VX+NiEzDgIjsyphkWwZEl1ki6biptRV3Zsa3e7tl9Zfa3RYyTV5xpd75vKNHZD4+MiO7YlkC01iiNEV6fLhFtts/yfDjG7KstDjt104V3y9E5mNARADaHsVsPlJi87FLkqKDMDglGp6SpDbdU5Iw+K+yBM5A9fxpnktd51ZuuqHXQdf5MlaQryfOVl5A9kc7ccOb2/De5uPKXmW9O4fAw8jNxgT7oqyuEX7e/AixBQltZUwAgV4yr5OzvV+IHBFHqjaCK49U7Qg9vKobmjBzRZ5T9jIzVGYiPMBbbXDDwSnReOHWXnh67UG1dfonRUKSIFs+Q/McnCqvxy1mlNMg1xUe4I11Dw9EXKRti9sSOTqW7rAwVw6IjC2nYAuFZfVapSMcnallJkwp0aDrdXDH0hakH8t1EMlj6Q4yirHlFGyla1SgWukIR2dOmQlTSjTIvQ7uWtqC9GO5DqL2Y0Dkxowtp0DybFVmQvV1YGkL0ofvWSLzsdu9E7JUiQt36+Eld95MPZcFpXX4tbACEoDYMH8rt7jNobM1GJYa03Z36EiJTfZJzsnW71mW2yFXwoDIiVg6AVrRY0lXDpGrfMDJnbcB3SIhBLCzwHASs2IbD362T215W3nlf0fwyv+O2Hy/5Dxs/Z51hM4YRJZm90dmU6dOhSRJen8uXpQv+Lh3715MnDgRHTp0gJ+fH7p27YqZM2eipMQ1/4q2RomLxdlpyEqOUpvmakP/y523HSfKtYIbfedy1op8uwRD5F5C/Mz7G9XW71mW2yFX5DB3iLKyspCcnCw7z9PTU2va119/jezsbDQ3N6Nv377o2rUr9uzZg3feeQerVq1Cbm6uzu05I2uVuAgN8May6ZlO2cPLGKaUpNB1Li1RLoPIGDUXmw0us3B8b/T7a1BMe7xnWW6HXJXDBET33Xcfpk6datSyZ8+exZQpU9Dc3IwPP/wQ999/PwCgpaUFU6dOxWeffYZJkybh119/hWTmAHaOxtolLrpGuVYgpGBOErLmuWQiMzmSjqF+yuvTHu9ZltshV2X3R2bmePPNN9HQ0IARI0YogyGg7U7S+++/j9DQUOzevRvr16+3Yysty90SoC3FnJIUmufSEuUyiCzF3u91fhaRq3LKgGjNmjUAgEmTJmnNCwoKwtixYwEAq1evtmm7rMkaJS6sXa7DXuVAVJlS6kLuXCrLWsSaNiBnRKA3EiMDjC6FQaS4/jISdNcrc4TyHK5SbodIk8M8Mtu8eTMOHDiA2tpaREZGIjMzE2PGjIGvr6/acrW1tTh+/DgAICMjQ3ZbGRkZWL58OfLyXCvBb3F2mlaJC3OSKa3dQ8TReqDInbe+ieE4+mcdqi9cLn8R4u+FF2/tBcBwSQ5DKuqbUFHP0hpkvGsSwtHU0oo9J+Ur2g/oFukwnR0s9VlE5EjsXrpj6tSp+PTTT2XnderUCR9//DFGjx6tnHbgwAH06dMHAFBVVYXQ0FCt9dasWYPx48cjKioKpaXtT4Z1tNId7U2Atna5DkcqB6JK9bw98+3vetvI8hjUXr6eEu7pn4islCgkRgbixwPnkHOsFMUVDThbdRGtKst6oK2Dg2ZJFwlAckwQPpqc4ZB3Xly1Mwa5Dqcq3XHVVVfhrbfewsGDB1FTU4M///wT69evx4ABA3Du3DmMHTsWW7ZsUS5fW1ur/H9goPwbMCgoCEDbiTBHY2Mjampq1H4cSXtKXFi7XIejlQNRpThv4q+26GrjtqOlLI9B7dbYInBXvwTle/WhYcl4cVxvnNYIhgCgFZAt6SIAHCups1WTTeZs5XaI9LF7QPT4449j1qxZ6NmzJ4KDgxETE4ORI0ciNzcXt9xyC5qamvDYY4/ZtE0LFy5EaGio8icuLs6m+7cma5frcIZyIIbamFcs/8iCyFSa17u5PRYd4X1D5OrsHhDpIkkSnnvuOQDA/v37UVxcDAAIDg5WLlNfL/8hUVfX9heVuY+35s+fj+rqauWPYt+uwNo9RKy9fVMTtRXLf7n7FN7adBQ5x0oNtjEtTndSK5EpLNVj0VI9txyhowORo3KYpGo5V1xxhfL/p0+fRlxcHBISEpTTTp06hd69e2utpwhgEhMTzdqvr6+vVjK3q7B2uQ5rbd/URG19SdHhAd7ITAzH3pNVsm3s0yUUof7eagnXROZ45tvf1a7RpOggDOgWiR0nTBv1XHM7pnK0jg5Ejshh7xABQHn55Q8NxZ2hkJAQ5QjUe/bskV1PMT09Pd3KLXRO1i7XYY3tm1oqQG55hcqGJhz5s05nG2etyGcwRBYhd42ak5rW3rIYLLVBZJhD3yFauXIlgLYgKDU1VTl93LhxePXVV/HFF19g2rRpauvU1dXhu+++AwCMHz/edo11ItYu12Hp7ZtaKsCYUhvVF5rwf4O74rlbeqq1kWU6yJI0r9GC0jqzauK1pywGS20QGceud4jy8/Oxbt06NDer1+9pbW3FkiVL8NRTTwEAZs2aBW/vy7d1H3vsMQQEBGDjxo3497//rZze0tKChx56CFVVVejbty+uv/562xyIk7J2DxFLbd/URG1jE1f3narUaiPLdJA1KK7R9l5f5iRXO0NHByJHYNc7REVFRRg3bhzCw8ORnp6ODh06oKqqCgcPHsSpU6cAANnZ2XjmmWfU1ouNjcXSpUuRnZ2N+++/H0uWLEFiYiJ2796NgoICdOjQAV988YXL1DFzR4oRohMjAw0mopZUX8Rbm44iPT4cg1Ki8fvpaqP24SlJ2Ha0rXt9Sc1FHDpX69jPkMlpJUa23R06X32x3dsxFUttEBnHrgMzFhYW4u2338aePXtQWFiI8vJyCCHQoUMHZGZmYtq0aRgzZozO9ffu3YuXXnoJOTk5qK6uRqdOnXDTTTfh73//Ozp06GCxdjrawIyuTC75c0C3SPx+thrVF9TvJEoAPD0kNLdyvCByTJ6ShGuTIuDl4dGuR7HtHdjUUQdLJbI2U76/7T5StTNgQGQ7HCGanE2InxdqLjbLzhucEo2mllbsKqww+prunxQJSYJaT7T29girbmjSKrXBXmbkDkz5/nbopGpyL0xoJkc28Zou6BLhD28PD5TUXkRUkC9u7BOLrlGBah0IACj/L4TAdYu26tzmv8b3xrVJkWrrKPLZLNnpwdodKYhcAQMichhMaCZHNqZPJwxLjZGd1zVKPcBQ/H/zkRK92+wQ6qdcVjNA0dymJVhjm0Sugjmk5DDMHcWXyBaY0Ezk2niHiLSo9vCyxF+Tiu15SkCLgNZ2VfcnN8q1HE9JgiSBCdVkdR4ScGWseu7B5WtaQosQOt8r1h4Znogsh0nVRnCXpGpLD++vr3zG4JRovHBrLzy99qDafLmE0szEcBz5s1atl1mYvzdiw/zwx7lak9tFpE+QryfqGltk5w3oFgkhIDu4oq73ChOaieyHvcwszF0CIkt3zdXXY8xTkhDi74WaC82y+1MdQfqZb383qedZ95hAlNVdQkUDy2+Q7Rh6rzChmcj2TPn+Zg4RAbjcw0sz6FAd3t8S21PdbmVDk879AcCw1BiIv343pRv+0ZJ6BkNkc4beK9YeGZ6I2ocBEQGw/PD+lipRwJ5n5GxYCoPIOTGpmgCY1htGM+laLgm7vT3GPKW2LsueLL9CToY9x4icEwMiAmBcbxi5JOnwAG9UqjyeUiSL6tqesSZ/vNvsY+mfFAlvTw+OeE02xZ5jRM6Nj8xIaXF2GrKSo9SmZSVHYXF2GgBg1op8bD9epja/UiNXZ/vxMsxckadze7YgSfbbNzm/UH/dPb8GdItE/79Gltak+l4hIufDO0SkpG94f2PLaqgmlnaNClTbnpeHhNOVDZi/+qBVj2PHiXJUNFzC9IGJdikFMiG9M4QAVued0bvc367vjlfXH7VRq1xLRnwYvL08MCglGjf07oRfC8ohAJwoqcPvZ6vRJcwfq/bpP/+6VF9owvLpmWhuFVqlODTLanj9VVyYPceInB8DItIiN7y/qcnNReX1aiUJjC1lYClF5fX47XSVTfalKT4yAH26hBkMiJr5OM9sg1Kj8ejw7srfNa/XzUdKzA6IgLYBP1XLdNiirAYR2RcDIjKKqUnSuhJLbVWeIzEy0G7Pg9Pjw9E5zN/gcmlxYdZvjItKjw/XO7+91xkTo4ncD3OIyCiKJGlDvb48JQmDU6J1/vVs7HbMpbr/IakxCPHTHfP3TQi3eFvCA7zR2irw3W9n0TtW9yBgfRPD0SLa2mDMOfXyYG87BT9vD5yruojNR0p0jvlj7nVm6PolItfFkaqN4C4jVRsiV4JAVy8zfSUJ5LZjjiBfT1zRMQS7T1Zq7V9A6CwbokquVMiAbpFoam5V264xgv08IUFCzcXLJUYUOSaqQv291MqQyC2janBKNOaNTsVdS37VSmI3dhua2sqh1KH6guEBLPVt29MD8PfyQN2lVvn5EnBVXBj2naoyeT99E8JxrKQOVQbaaErJDFVyZThYUoPItbB0h4UxIFKnmXRtbkmCiR/swN6TlWhPfdbBKdFqZT4U+9dXNkSVXKkQ1cTZXwrKIQHw9JDwzs/HcKriAlS3KAGIj/THC7f2xqwVebIBS4ifF54acwUEgNV7T2PfqSqjhgPwkIBrEsKxasYA5bScY6XYd6oS6fHh6BIegKLyery3+Tj2nVTfpqIg6eLsdADQmQAst73EyECcrmxQTh+UEq32Gu8pqsD2E2XI6haFiRlxyu08+fVvOFt9Ufb8XrjU3PZaG3gt0hPC8NCwZK02/t+ne3CxWVfQZXzJDMW5kEuQZmI0kesx5fubOURkMs2EUnMSTAtK67C7yLQ7MHJUy3yobtvYu0+apUJUqR5X2+CTF7TWFwBOll/A2aoLOu/e1FxsRudwf3QO88f81QeMahcAtApgd1GlssceAAxKicaglOjL+xdC9jy2CuDgmRqt49CkuT3VRHjN6arzFIGQQucwf61gCFA/v4a0/HUsmoFJa6vQGQyp7kP1PKmSu171zSci98QcIrILS5bk0CyVYM62DZVbMLRNuernqvadqjT7mPW1zdIlV8xlzdcz38jegiyZQUTtwYCIrK6gtE4rAdaSvc0UZT4U2zdn24aSlg1tU9dgfQrp8eFmH7O+Hk+mlFyxJku+npptvrpLmFnrERGZggERWU1VwyVMXrIL1y3aimmf7Maw17Zg8pJdqG5oslhvszB/b0z+eLfa9iMDfU3e9j1LdinbJkdXexW9ku7oG49wHYm44QHeGJQSbfIxG9PjyVC7bPUoyFA72tNDcUhqjM5zq289IiJTMCAiq5Er9WGotEdmYgRC/dVT20L9vRDs6ym7D80eSIrtm1O6Q7VtcgyVNln38ECtL+7wAG+se3ig3m3o+rI3thSEoXbZir52GHPc+tosd26NWY+IyFjsZWYE9jIzXUFpHa5btFXn/M1zh+rt5aPa+6lzmL/ebenbvlyJheKKer3FY1XbJsdQryTVtqsmJuvbhiVKQThKbyl97WhvD0XFuY0N9UdUsK/dj5WIHBt7mZHdGZPsK1faQ0G195M55T4U25fbtqHkW9W2yTHUK0mz55Yx27BETydH6S2lrx3tPW5jzi0RkTkYEJFVmJPsW1Bah18LywFI6JcUqfyiNCdh1xkSkYmIyHEwICKrUCTZag6OqBhET/WuQFXDJTz0+T610aKBtp5bH9x9jc5tyZHbvqqqhkt4dt0fZq1LRESui0nVZDXGJvvOWpGvFQwBbWP76EvA7p8UiQHd1Lu7G0qwlUv0NnZdIiJyXbxDRFYTGuCNZdMz9SbOGhpVWnUEYl3bMjYx19C+nrulJ2tYERG5KQZEZHX6EmeNGeHYUAK2sYm5piR6ExGRe+EjM7IrYxKmLZXkzGRqIiLShQER2ZUiYVoXS45A7CijOrsiufIsRETOhAER2d3i7DT0TQzXmh7q740Xb+1l8X05wqjOrkJfeRYiImdi1kjV9fX1+Ne//oVNmzahpKQEra2tavMLCgos1kBHwJGqrW/ykl3IPV6KVpWrUdENftn0TIvvz1FGdXZ2k5fs0jm0gjVeNyIiU1h9pOr77rsPW7duxT333INOnTpBameBTnJvunp/tQih1svMkhxlVGdnZo/XjYjIWswKiH788Ud8//33yMrKsnR7yA2x95dz4utGRK7ErIAoPDwcERERlm4LtUNBaR1OVjQ45SMg9v5yTnzdiMiVmJVU/fzzz+Mf//gHGhoMjyFD1uUKSa3s/eWcFK+b3IdIeIA3IgJ8bN4mIiJzGR0QpaWlIT09Henp6Xj99dfxv//9Dx06dEDv3r2V0xU/7fXEE09AkiRIkoQXXnhB53IbN27EmDFjEBUVBX9/f/To0QMLFixAXV1du9vgLORKUWw/XqYseeEs2PvLOS3OTpMd3bvmQpPTXYNE5N6MfmR26623WrEZl+3YsQOLFi2CJEnQ1wHujTfewOzZsyFJEgYNGoQOHTogJycHL730Er755hvk5uYiKipK5/quwJWSWo0p80GOp7y+EZUydyNbBJzuGiQi92Z0QPTMM89Ysx0AgIaGBkydOhWdOnVC3759sXbtWtnl8vLyMGfOHHh6euK7777DDTfcoFx/7Nix2LRpE2bMmIGvv/7a6m22J1dMamXvL+fiitcgEbkns3KIkpKSUF6uXZ28qqoKSUlJZjdm/vz5OHbsGD766COEhobqXG7hwoUQQmDatGnKYAgAAgICsGTJEnh4eOCbb77B4cOHzW6LM2BSK9kbr0EichVm9TIrKipCS0uL1vTGxkacPn3arIZs2bIFixcvxuTJkzFmzBh89dVXsstdunQJ33//PQBg0qRJWvMTEhKQlZWFnJwcrFmzBvPnzzerPc5AkdSqa2A8R/7LfOuREuSfrkJ6fDgGqZTu0Owt986mY9h+ogyDUqLRMzYEH2w9gaqGJsRHBMDf1xPdY4JRWtuI4soGJEYEIjjAC51C/RAd7IfEyECcKq9H/ukqtWmOfF6cjTNfg0REqkwKiNatW6f8///+9z+1uzgtLS3YtGkTunbtanIj6urqcO+996JDhw5488039S579OhRZe+2jIwM2WUyMjKQk5ODvDzXT+pcnJ2GmSvy1HKJHDkZ+WR5PW59d7ta3kl4gDc+u/davPy/I7I5UQCws6BC7fdD52vNbsPglGidycBkOme7BomI5JgUECkSqyVJwpQpU9TmeXt7IzExEYsWLTK5EXPnzkVhYSHWrFmD8HDtmlaqCgsLAQBhYWEIDg6WXSYuLk5tWVfmbMnImsEQAFQ2NOGW97bD9CIy5lH0wmNpCctwtmuQiEiOSQGRomZZ165dsXv3bov04lq/fj0+/PBD3HnnnUb1ZKutbbszEBio+wM3KCgIQFsNE3M0NjaisbFR+bu527ElZ0hG3nqkRLZHEgA0t9ooGoJz9sJzBs5wDRIR6WJWUnVhYaFFgqHq6mpMnz4d0dHRWLx4cbu3ZykLFy5EaGio8kdxx4naJ/90lb2boKaovN7eTSAiIgdhVlL122+/LTtdkiT4+fkhOTkZgwcPhqenp97tPPbYYzh9+jS+/PJLowMsxWOy+nrdX2aKgRnNrUw/f/58zJ49W/l7TU2NSwVFli7zIbe9gtI6LN95EsWVDbh4qQVl9Y0oq200sCXbSowMVLbdU2obO8fUc+LMJVMUbH0MrnDOiMj1mBUQvfHGGygtLUVDQ4My56eyshIBAQEICgpCSUkJkpKSsHnzZr2BxJo1a+Dl5YX33nsP7733nto8RZf5JUuWYOPGjejYsSNWrlyJxMREAG1d/Gtra2XziIqLiwFAuaypfH194evra9a6jqyq4RJmrchXS35tT4Kx3Pb6J0Wi/lIzfjtdbZE2W4unBDz59W/YVVShNc+Yc2Lpc2kPtj4GVzhnROS6zHpk9tJLL6Fv3744duwYysvLUV5ejqNHj+Laa6/FW2+9hVOnTqFjx454/PHHDW6rubkZW7du1fr5888/AbR18d+6dSt++eUXAEBqaioCAtrGPtmzZ4/sNhXTLVFGxJVYusyH3PZ2FpQ7fDAEtN0NkguGAOPOiSuUTLH1MbjCOSMi12VWQPT000/jjTfeQLdu3ZTTkpOT8dprr2H+/Pno0qULXnnlFWzfvl3vdqqqqiCEkP1R9GJ7/vnnIYRAUVERAMDHxwc33ngjAOCLL77Q2ubJkyexY8cOAMC4cePMOTyXpCjz0aLRlUs1wdgS23MFhs6Jpc+lPdj6GFzhnBGRazMrIDp37hyam5u1pjc3N+P8+fMAgNjYWGWPMEubN28eJEnCJ598gp9++kk5vaGhAdOnT0dLSwsmTJiAHj16WGX/zsiYEguW3J4r0HVOLH0u7cHWx+AK54yIXJtZAdGwYcPwwAMPqA18mJeXhwcffBDXXXcdAODAgQNmDdJojPT0dCxatAgtLS0YM2YMhg0bhjvuuAPJycnYtGkTUlNT8cEHH1hl387K0iUWDG3PFeg6J65QrsLWx+AK54yIXJtZAdGSJUsQERGBa665RpmAnJGRgYiICCxZsgRA21hA5gzSaKzHH38cGzZswKhRo/Dbb7/h22+/RVBQEObPn2+xMZIcQUFpHTYfKWn3IwVFiQVPSVKb7ilJGJwSrdbbR3OfBaV1WLHrJFbsOoVtR0uxYtcp7CqsQO/OIfBQ35xL8JCAXp1DUFzRIHvuTTmXtmDONWLrY3C0c+ZOLPUZQuTqJCHMTwI5fPgwjh49CqAt2Tk1NdViDXMkNTU1CA0NRXV1tdld+U1ljR451Q1NWiUWVLcpt88wf29UXZAfTNGdaJ57Q+fSFtp7jdj6GBzhnLkT9uojMu37u10BkbuwR0A0eckunQUz21tyQleJBbl9Uhtd596e5SosdY3Y+hhY4sM2rPkZQuQsTPn+NmscopaWFixduhSbNm1CSUmJsqSHws8//2zOZukvih45mixVckKuxIKufVIbXefeXuUqLHmN2PoYWOLD+qz9GULkiswKiB599FEsXboUN954I3r16gVJcsFEEjsypkeOpT/M3KHXmCVY49ybwx7XCDkPXh9EpjMrIFq5ciW++uorjBkzxtLtIVi/R87lchUS8osrUVHfBE/GtEbxlIDNR0qUj3u+3HUKOwvLkdUtChMzbFfehb22TGfvkiG23L+trg97n1NLcIVjIMswKyDy8fFBcnKypdtCf1H0yNH1/N/cN61ckiWZZvLHu2Wnr807i/mrD2Ddw1m4snOo1dthrWvEFdk7udge+7f29WHvc2oJrnAMZFlmdbufM2cO3nrrLTAf23oWZ6chK1l96ICs5Cgszk4ze5typRPIcppbBca+q390dkuyxjXiiuxdMsRe+7fm9WHvc2oJrnAMZFlm3SHKzc3F5s2b8eOPP6Jnz57w9laPplevXm2Rxrmz0ABvLJueabEeOUyato3mVoFVe4pt8vjM0teIK7J3crE992+t68Pe59QSXOEYyPLMCojCwsJYJ8xGLNUjh0nTtrP9RJlN84nYa0s3eycX23v/gOWvD0c4pvZyhWMgyzMrIPrkk08s3Q4ykTGJgKrLmPVslMzSPSZYLfGa7MdWHRR0vdbt2b+lkn1VtyOEMHubBaV1+LWwAmW1F/UuZ8+EfmPPmaHXRbPzhC0Sr03Zh7MlgjtLe80KiIC2Qq5btmzBiRMnMGnSJAQHB+Ps2bMICQlBUFCQJdtIKoxJBGTytH298r8jyv8zSdO+bNlBQe61Nmf/lkr2NfQ5YOw2qxou4cHP9mFnQbne5eyZ0G/qOUuKDsKAbpHYcUL7mEL9vdU6T4QHeKOy4fJo/ZZ+T5vSdmdLBHe29pp14+DkyZPo3bs3brnlFjz88MMoLW072Jdffhlz5861aANJnTGJgEyeth/N2m5M0rQ/W3VQ0PVam7p/SyX7GvocMHabs1bkGwyGAPsm9JtzznT1CarWKFWkGgwZs11TmdJ2Z0sEd7b2mj0wY0ZGBvbv34/IyEjl9HHjxuH//u//LNY4UmdMIqD46/9kOyOuiEF6fDhe+d8RtGp8yDJJ0/5s1UFB12ttyv4tlexrTCcKY7ZpzHYWju+NfkmRdru+zTlnBaV1RgV5ciz5njal7c6WCO5s7QXMDIhycnKwY8cO+Pj4qE1PTEzEmTNnLNIw0mZMIiDZ3l39EgwuwyRN+7NVBwVdr7Ux+7dUsq8pnSj0bdOY7XQM9bPrtW3OObNEJxNLvKdNabuzJYI7W3sBMwOi1tZWtLS0aE0/ffo0goOD290okmdMgibHhrI9Y847R452HdZM1LbUtg1tx9htGrMde1/b5pwzU86PKds1lSltd7bR6Z2tvYCZOUTXX3893nzzTeXvkiShrq4OzzzzDMt5WJEiQdNTo3acpyRhcEq0sgdJ34RwrWXI8hTnvWtUoMHXxtZ/CRWU1mHzkRIUlmnfNdQ3z5ba0w5j1lUss+1o6V//lljkuJOig5CREK714ekBoG9COIQQRu1H9RgU/5f+ul40ryMPQPkeV6yz9UgJ3tp0FF/tLlabdt+nu/H0moPoHhOo93PAQwL6JoarXZua51VxXevSu3MIisrrrX4t6Xu9k6KD0KtzCDSPVNd7T9HjqW+ieZ+TEtqOW2675lxfvTqHaOUeyrXd0T5jDHG29gKAJMy4pXD69GmMGjUKQggcO3YMGRkZOHbsGKKiorBt2zbExMRYo612U1NTg9DQUFRXVyMkJMSubaluaMLMFXlqz2YHdIuEEFB7Ju4BoNUO7XMnmr0l5F4bW/eo0NerQ0A4RI+P9vQ8sVQvS3OP29QenHL7MbSN/kmRaG5txe6iSrXpYf7eqNJI+LWEwSnReOHWXnh67UHZ81pcWY+xi7cb/DyxxrVk6PU+WV6PW9/drpX4DLT1Dlv38EDERQbo3JaXh4RmzcQ/Iym2H+zvZfL1bOga8PKQZMsAnSpvwC3v5qodr+ZxOhJH+Ew05fvbrIAIaOt2v3LlSvz222+oq6tDeno67rrrLvj7+5vVaEfmSAGRgmqC5jPf/q7VrZesxwPANQnhWPXgANn59hw5evKSXTq7eAPQOW/Z9EyHaKOhdhizrtwymsw9bmO2bWg/hrbhKUkI8fdC9YUmrSR9a1Dsr+ZCs+x5PXCmSjbgkNuOpa8lQ6932j/X62ybOdeFqcIDvNG7c5jJ17MxbQkP8EbeP643uJ493sOmsudnoinf32aPQ+Tl5YW7777b3NWpnRQJmizJYXutAHafrNTZS8JeI0cb6tUhx9Y9PtrT88SSvSzNOW5z3mua+zG295cxAYil6NqfvutG13YseS0Zer2/3HVK73myRe/byoYms3q4GdOWyoYm5BwrxaC/Hlk6Y68tBWcZTd/ogGjdunVGb3Ts2LFmNYZMx5Ic9uNovSTacy3Y6lja0/PEGr0sTTluS5xfd3i/WupaMnSudhYa123enr1v29vDbd+pSmVA5Iy9tpyN0QHRrbfeatRykiTJ9kAj67BEbwkyj71LFPxaWAEJQGyYP1qEaFcivSnHYqgUhNx8TwloETDYRtWSCarbPlXeljBs6BhMzQD440w1th4pRVSQD27sEyvb3vziKlTWX4JnO/opeErAc+t+x5HzNeZvxEl8l38WpTWNiA7xRUnNRZyvuYj0+HDlF/vWIyVYm38GEiR0iwlEc6tAenw4WlsF8k9XoVOoH85XXzSYnOxt5PX++5lqFJbaJyj6/Uw1fj9djeNldcjqFoWJGXEmfWbHhl5OQTG0nuKc6SrPoq98hqHSGs5SeqO9zM4hcieOmEOkyhrPxkk3ez6zN7aMgipL5RAZSgSVS+6XEx7gjeqGJq0kXXMTXG2RK9Ie7ODQJsTPC6JVoPaS6/zBrAicjaVIln7++0NGv4dVk5BNvbYNJcwb6mjhbKU35NgkqdoYvXv3xg8//IC4ONtV/rYGRw+I5DL5yXrs+YEweckuk19nRXsBtKvHh6UCDQ8AHu3o3aPJmN5+RI7Cy0NCZtcI2TpqclQDflOvbUMJ84D+P5KcNYlblcMERMHBwdi/fz+SkpKstQubcPSASKGwrB4vff8HNhzS/2iBTPfqbX0QFexr11vGBaV1uG7RVpPX2zx3qFqbzenxYe6+rWnO9d1xU59Ynbf4Ha29RO2heB/b6tpedm8mJn+8y2B7HJ0p399mDcxIjqlrVCCKK10/adMeooJ9MSw1xqFLFOiimVTaNSrQ5GNxxGTgViHaVXKCyJko3se2urbziiv1znfFUlEMiFzMgKQowwuRyRxhmHlzE+htUWLAHtLjw3XOc8T2ErWH4n1sq2s7LU73+wtwjM9ESzN7HCJyLAWldfjvb2eZvGlhiuflptxN0eyRYahXlr51NadlJIRjz0n9f7mptj09IUz5l5zc9lTb5ylJf/VWa0sU1WxvRkI49p2stMg15iGhXYMOBvp4Iu9UJTYdKkF0kA9K6y4hKsgHfbqEokW09e4J9JZQ3+QYidXkeBIjA3CqosEmg1+q8vKQcHVcmEnvY9XPIEXpGGPei4ZyiCoaGvH7mRoIjXWykqMwuHs0BqdE68whMuVxuzE91ByhJxtziIzgyDlEVQ2X8H/L9mgN80+WYUrSsVyPjPAAb52DxxnqzWFsry1dNPcttz197SMi3UL9vZHaIQi7TPzsvapLKPafrpadJ9drbUC3SLx/1zU6Pyf0GZwSjRdv7YUFGr3MMhLCcbykTrYUjGopkPaU3jC2h5q1e7IxqdrCHDkgMqfXEcmT0FZo8e3sdLOGmW9PWQdzenBJAJJjgvCPm69Ec6tQ3sIuKq/Hez8fx75TVQ7T9ZzIlfSODcF3swYBuNxJQTFshOJ9eP+y3TheUg9D70AJQKcwP0QG+uCPs7Vq71kPAANTok0eUkKuvJBqZ4rx78nXfwPke5GZ0xHD2B5q1u7JZvXSHcuWLcMdd9wBX19ftemXLl3CypUrMXnyZADAhx9+iA4dOpizCzICy3ZYlgBw4EzbwHnDUk0rUNyesg7bjpaa9ToKAMdK6tAlPEDtQ0oIgd1G3o4nItMdOFujLJUhV5aioLQOx0qMSzoWAM5WXcTZqota81oBs8qPyJUXUrRz65ESo0ueaK5rLGPLjDhaORKzkqqnTZuG6mrtW361tbWYNm2a8vdJkyYhMND1Eq8cBXvSWIc5vSfa81oY6s1hiGZ7eV0QWZ++zwlLvweLyuvN2qZcG/NPV5m9rrGMLbNjjXI87WHWHSIhBCSZYdNPnz6N0NDQdjeK9LucBGvvlrgmxS1vXQnO//3tLCrqmzD8ihh0DvNXJiSby1BvDkP+ONv2x8kfZ6pxrLQO3WOC27U9IjJs65FSeHlIypIkbdNKlOVHLMmcsjQA8Odf5TxU77Jc3SXM6H0aS/Oz0lBPuMTItrtD56u174qZ2wZLMCkgSktLgyRJkCQJw4cPh5fX5dVbWlpQWFiI0aNHW7yR1EYu+SzU3wvVF5rt2CrXoXhuHf7XEPmaCc4XLzVjX/HlO6NLdxSprR8e4I2aC01GD+VvqDeHsV7931GT1yGi9lm6owhLdxQhPMAb70+6Bg9+sVftUZSXB9BsQpdMLw8JrUKo9XpT7dFV1XAJYf7esonQusxbfQCAepLykNQYvZ0pTOlFpi8hWlcPtcyuEXjm29/1Pv4zp3evJZiUVP3cc88p/50zZw6CgoKU83x8fJCYmIgJEybAx8fH8i21I0dJqna0Gk2uRvFGnrkiz6zz7AEg1IReW6ofUiw3QeQeQv29Ua0jqNGs56dZx0zX54OhP4w1k5SLyxsw9t1c2c+q9pbzUexL8VmqGSw1t7bi14IKvZ+vTtXL7NNPP8Udd9wBPz/L3hZ0VI4QELEUgfVtnjsUQgibnOfl0zPVbrUDfI2JSL5MkKU+GzTLbeQcK8W+U5WIDfU3uTSRoTYp9qXaQ83Q5+u/xvfGtUmRFr0zZPVeZlOmTAEA7N27F4cOHQIA9OzZE2lpaeZsjozARFnrs2UCn1xhU77GRHS2+gImZqgXRLfUZ0NRuXo+0aCUaK0/zIxlTEK0Zi+8zUf019nsEOpn1/JIZgVEJSUluPPOO7FlyxaEhYUBAKqqqjBs2DCsXLkS0dHmnWDSjaUIrM/cxEVz96WJrzERyZWksdRngyWTlI1JnLbEOrZkVrf7mTNnora2Fr///jsqKipQUVGBgwcPoqamBrNmzbJ0Gwltw7UPToluV28mkucpSRicEo2uUYFIig5C38RweJhxmj0lCb1iQxATrDuHTrGvU+X1eHbdQSz++Rje2XQM9326G5//chKJkQyKiCzNU5IQHuBt989Pxfs/xE/+XkR4gLfsHRvF578ug1Oi9X4/qH7GWYqu7yR9+zJnHVsyKyD66aef8N577+GKK65QTrvyyivx7rvv4scffzR5e59//jkmT56Mq666CjExMfD29kZoaCgyMzOxcOFC1NXV6Vx348aNGDNmDKKiouDv748ePXpgwYIFetdxVouz05CVrF68tX9SJNLjONSBQrCv9geNl4HoJsjPCy/e2gtVDZcwecku7C6q1Kpv1DcxHCEy21YncPBsDUpqL+lc4pqEMOQXV2LKJ7uxdMdJLFp/FK9tOIqNh0qwZHsRisr52Izcy5WdgtE/KdKq+8hKjsK6hwdqfX7KCfLxNGnb4QHe+PL/+iHciATgzK4RaG5tRc1F7QRoRckMXRZnp2FAN+3z1D8pEouz02S/HxQUSc6WJrdPQ/syZx1bMSupOjg4GDk5Obj66qvVpufl5WHIkCGoqakxaXsDBw7Ejh07cMUVVyAuLg4RERH4888/sXPnTly4cAHJycnYunUrYmNj1dZ74403MHv2bEiShEGDBqFDhw7IycnB+fPnkZqaitzcXERFtb/6uyMkVavSHEZ98pJdyD1WalLRTS8PYPbIVGw+XIK9FirYaYi3B9BkpR35enngp8cGK5P4fikohwQoE/RyjpXi6TUHcLLiguz6ir++NHtMKIbA9/fx0p4ntc17aFgyHl2RJ/shp7md46V1Fq0d5uflgUstrTYvUEkEAOH+3vD19sCFSy2o1nP96+IhAQOT20pTTPxgR9tnkZ5rOdjXC3f0jUNWShS8PCScrrwACcDnv57E72dr1NaVAPTsHILF2elqdx4Un5/vbT6uswZk38RwjE/vovwMOV3ZgH2nKpEeH45BKdHKZGTF7wo3L87BQY1iqR4ScGVsWzue+fZ3rc8RRcmg72YOMuqcFZbV49eCcggA/WQSkOVKiVj7zos5pT3MWcccVk+qvu666/Doo49ixYoVyiDlzJkzePzxxzF8+HCTt7do0SKkpKQgIiJCbXp5eTluvfVW5ObmYs6cOVixYoVyXl5eHubMmQNPT0989913uOGGGwAADQ0NGDt2LDZt2oQZM2bg66+/NucQHZpqkpq55TuaW4GoIF+blniwVjAEAI3NrThd2aBzKP22ARTlgyEAOs+hYgh82XkC2F1UiZLqi3qDIUPbaY+Lpgx0QmRhlReasCy7LyZ/vNus9VsFlOVrjClQXdvYjLv6Jai9vwtK65Tj7agSAA6e0f7jvGtUW66gvv3tLqrEK7ddpVa6QjXwkUtGLiitU5b+0TzGg2dqUFzRIPs5oygZZGyZCkNlNEwts2EJ5uzTHu00xKxHZu+88w5qamqQmJiIbt26oVu3bujatStqamqwePFik7d37bXXagVDABAZGYmXXnoJALB+/Xq1eQsXLoQQAtOmTVMGQwAQEBCAJUuWwMPDA9988w0OHz5scnucSXt6H+woKLNgS+xv3yndH3DW7MG1s9C8avREriCvuMoC2zD+jwVTS9XI9R415vPA1F6nhrZp6BhtXaaCtJl1hyguLg779u3Dxo0blQHHFVdcgREjRli0cQCUo2GrFpK9dOkSvv/+ewBt9dI0JSQkICsrCzk5OVizZg3mz59v8XY5ivb0PkiJdq0SD16ShLc2HUV6fDhaWwXyT1fBS5LQLAQ6hfhbbb+lNY1W2zaRo0uLC2v3Nkx5f2r2RDL0GSiXQ2jM56apPZ4MbdNQiR5797AiMwMiAJAkCSNHjsTIkSMt2R41tbW1ePbZZwEAY8eOVU4/evQoGhraovGMjAzZdTMyMpCTk4O8vDyrtc8RKLL2zRlZ+dX1R6zUKvt4db11Slh4egAtep5MbT/BO0TkngZ0i0SfLmF6S0EY44lvfkP4XyO263sI3F8mZyYpOgj9kyKxs0D+fXjPkl1aIx8rPjd1PSo3p8eTrs9iQyV67FWmgrSZ9cgMALZu3Yqbb74ZycnJSE5OxtixY5GTk9Ouxqxfvx5Tp07F5MmTMWrUKHTu3Bnr16/H6NGj8fLLLyuXKywsBACEhYUhOFj+LkdcXJzasq5MX+8Caj99wRCROQz1fHQWQgCzVuSjxoT6WrrUXGiCh4HzoqvXvKHe9NuPl2HmCvU/jhdnp8n2bhvQLdLsHk+GelA5cg8rMvMO0WeffYZp06Zh/PjxynGHcnNzMXz4cCxdulT2MZYx/vjjD3z66adq0yZNmoTXX38doaGXu5bX1tYCAAIDdUfUijprpvZ4A4DGxkY0Nl5+DGLONmwpNMAbz469Uu+Q6KN7dsBPv/9psza9elsfNLcKHD1fi080iqCS7fxtVHeHL/46Z2R3LNrg2G00xsgrYxDs641x6Z0BQKskgmZPpS93n8KT32gnA9uTonTC7sJyPGFE23TdlTFHi0BbhKXHjhPlWsnHBaV12GHgLm2LENh2rFRt3dAAb6y4v59sr1RzhQZ4Y9n0TJ09qAzNJ/syKyB68cUX8corr+Dxxx9XTps1axZef/11PP/882YHRI899hgee+wxNDU14dSpU/j222/xwgsv4KeffsKaNWswePBgs7ZrqoULFyoL2ToLQwl9V8SG2DQgigr2xbDUGLy1yfm/6JzZsRLHH4+rFa4xZsCkaxMwLDVG+btmLyTNnkrnay7arG3GUpROcOQEX83yE6Z0mNBcF7BObydH7AlGhpn1yKygoAA333yz1vSxY8da5BGVt7c3unXrhtmzZ+PHH39EZWUl7r77bly40NZtWvGYrL5e95tWMTCjOeMGzZ8/H9XV1cqf4uJiM47CegpK67D5SAkKyy4fv6GEvo4hti3Eq3gkcHWXMJvul9RZe8A7SzCUbOosFEmxcu9PuemO+N5QHIMjl5ExNala37pEqszuZbZp0yYkJyerTd+4caMyd8dSrr32Wlx55ZX4/fffsWfPHgwaNAiJiYkA2uqn1dbWyuYRKYIYxbKm8PX1VevV5iiqGi5h1op8tURARbKgoeRqW9+av2fJLvRPijT4bJ+sQ5GoeUffePzrx8MWHQzSUjwlCZldI/CfHOP/iDK3A4G1DU6JRniANyYv2aX1/nzh1p54eu3vsu/b9iYje3lIEALtPh+qib1VDZfw7Lo/2rU9c4X5e6P2YrPs8ehKPjamYwkTl8kYZt0hmjNnDmbNmoUHH3wQy5cvx/LlyzFjxgw89thjmDt3rqXbqMwVKilpq5SbmpqKgIC2vwr27Nkju45ienp6usXbYy+zVuRj+3H1sYNUkwXbm1wd6m946HlT7CwoN/hsn6xDNVFz3cMDjSorYCmZieHwMuKTJSs5CpIErWtaly//r59FOxD06RyCMAtc830TwrE4O03n+/OWd7frfN/KvTah/l7ITFQfl61vQrhWW9tKPWRZ5HyoXi9yx2Gq/kmRsmUmDEmJCTKr/ISh64KJy2QMs0p3AMCaNWuwaNEiHDp0CEDbOER/+9vfcMstt1i0gWVlZejSpQsaGxvx22+/oXfv3gCA22+/HatWrcJ9992Hf//732rrnDx5Et26dUNLSwsOHTqEHj16tKsNjlC6o6C0Tm/S9Oa5Q9E1KtDgcrosn56JQSnRymHhS2ob8boLJLq6k1dv66NM4NX8S3jrkRJM+cS80YRNsXx6JjqH+Rt1DS67NxOTP96lc/59A7vi97PVGJQSjYeGqd+N3na0VO+6T4xKRf6pKtQ1NuPK2BAE+3vB28MDJbWNiArywY19YpXnSFGGwUuSTB66QfG+Mfd9p3jfypWCkEu81VUyQrFsWW0jdv71R0i/pAi9idHLp2dqlXYwdBzLp2fidOUFzJcZGVp1GbljANpyeDwl6B3ZevPcocplTS0/Ibc/Ji67N6uU7nj77bdx//33w8/PD6dOncKtt96KcePGtbuxf/zxB/Ly8jBhwgT4+annuRw9ehQPPPAAGhsb0a9fP2UwBADz5s3D119/jU8++QQTJkzA6NGjAbSV7pg+fTpaWlowYcKEdgdDjsKY0Vi7RgWaPSJz819FgBTJfpuPlJi1HbIfRSK7nPzTVTZpQ3OrMPoaNDRyb1ZKFJ6+6UrZeYYeEV0RG6IVROmiKMNgzjWveN+Y+75TvG/lSkHIJd7KLae57MSMtrQFQ8fT3Cq0rhdDx9HcKtAxVH8+YrNKQTHNYzDms6WovB7DUmPMCmLk9kdkLKMDotmzZ+POO++En58funbtinPnziEmRv7D1xQlJSW4++678cADDyAtLQ1dunTBpUuXcOrUKezbtw+tra244oor8OWXX6qtl56ejkWLFmH27NkYM2YMhgwZgpiYGOTk5ODcuXNITU3FBx980O72OQpDiYPtTYZsT6IiOQZ9CaO2SuBNjGyrE2WM9ozca+z7wRTmXPOWft9ZkjnnyJh1DL2+ho7JGq8dkSUYHRDFxsbim2++wZgxYyCEwOnTp3Hxony30fj4eKMb0LNnT7z44ovIycnB4cOHkZeXh6amJkRERGD48OEYP348pk2bJpvk/Pjjj6N3795YtGgRdu3ahfr6esTHx2P+/PmYP3++zkEbnZGhUVAVfwmZOnK1BKBTmB9++O0cmkUrvCQJpXWNiAzyRfeYQBwrqXeRTtGuS/UaKCitw8mKBq3HBENSY9qdwGtsGwD9yc+WGLnX2PeDKUx57xj7vvOUJIT4e6HmgnqisAeAaxLCrXoHw5xzZOw6cst4ABj41wjPqtehEELtmrTGa0dkCUbnEH300UeYOXMmmpt1V/UWQkCSJLS0tFisgY7AEXKIAKC6oQkzV+TJ9lYJVUnMlFuOrMsD0FtywBSKvAmFMH9vxIX748BZ+QFC23oy9cLTaw/qvTZ+P12Nse/mtg2Ap0NmYgSO/FmD6guX3+eh/l5I7RCCXUUVOtfT3Je+a1B1WWOvaTntWdeUbcox9n03OCUaL97aCws0XhtLtdcQc86RMetUNzRhxmd7tQZm7JsYDm9PD52dKRTbAWDx145Ijinf3yYlVdfW1uLkyZPo06cPNm7ciMhI+V4EV111lWktdnCOEhApGDvKqWaC4c2Lc1DX6FrBqj4BPh748J4MZVKmYqRgbw8PfLmnGMUVDWg14faXhwT0jA2BAPDH2Rq1dRV/3fZLikDOsdK2nJTDJdh9Un+ejATgldv6ICMxAkXl9Xhv83HsO1kle5eh+kKT2j49pLa7DKtmDMDkJbt0/sW9bHomAGh1CVfVq3MIFmen45lvf9e5nedu6amW6GpMwqviGjS0bHtG7rXGqL9y7QaMS9LV1Z6JH+zA3pOVsteN4jWyFnPOkaF1Ji/ZhdzjpSa9hzSPlyM2k7VZJakaaBsQsVevXvjkk0+QlZXlkGP1uANjRzlVXW7rkRK3CoYAoOFS2z0bReKoInm1oLQOr/zP9MK2rQI4cEb+Lo2iNMBzt/TEQ8OSjd6H4ruka1Tbo4XdRdoBVIsQso+6WgWwu6gS246WygY6quUKxF//1+XgmRoUV9Tr3Q4AnUnbuphzrZrKliMNm3ssBaV1Ol9bzZIS1mDOOdK3TkFpnVl3oDWPlyM2kyMxaxyiKVOmMBhyMrbqZeRo9p3S/hIyt0eQMRQlD0zZx/YTZSavo8pQb62i8nqjtp1XXGVwO2QeY3qJOpP2voec7XjJPRh9hyg8PBySkcMOV1TozjUg8+hKljW0jGLa72eqbdlch+Ht0RbzF5TWYfnOkyiubEBafJjV9ucpSdh8pASeJozQHRXY9seFuT2VvCT9f9eUVF/EofOGCxSnxYXpnf9n9UWr38kwlzHvj/Ys316u1rOqvb1Qne14yT0YnUOkWoW+vLwcL7zwAkaNGoX+/fsDAHbu3In//e9/+Pvf/65W9NUV2DOHSF+5DkXyodwyirIZHCka8PQAWiyV8ayHZjJ0qL+XWnKyPm2jDg/EgrUHje6ppLnvllah1iPQQwI8JPU26TI4JRpvZ1+NYa9tMdgTzZGSX415f7RneUsyJs/LmcgdjyHOfLzknKyWVK0wYcIEDBs2DI888oja9HfeeQcbN27E2rVrTd2kQ7NnQGRssqwj1nci04QHeGPL3GEm91RS0AzINH/XZUC3SLx/1zWYuSIP24+X6u2FBjjWl5qpQYY9gxJr9IqzJ7njMfSHmDMfLzknqwdEQUFByM/P1yruevz4cVx99dXKSvOuwl4BkTHlOoQQZpUMIMekWkJFrvfNl7tP6S3UqyjfUVJ9EU/qKa8wPSsRKR2CcW1SpNklXxRlJ+zF2HI25i5vLa7Ws0rueFhCgxyFKd/fZiVVR0ZG4ttvv9Wa/u233+rsik+mMyYR05oJwmR7iiTwrlGBsuULztfID4aqcLb6AoalxuB8rf7lQgK8cWdmvHL75lxH9k6MNTVR2VESm3W9ts5K7nhUp7na8ZLrMqnbvcJzzz2H++67D1u2bMG1114LAPj111/x008/aRVaJfNZYhh9ci7p8frLWRgqwaFY39jlFNpTtsJeTE1UdrXEZiKyLLPuEE2dOhXbt29HSEgIVq9ejdWrVyMkJAS5ubmYOnWqhZvovhRD3Htq9O7zANArtu3WX3FFAxIi/O3QOjKHpyTBy0O+C1p4gLds4U5VihIchtaPiwhAkK+n7HIhfl5obhUoLLt8R0TXtabrGAb/VaLBnnS1WVf7TF0eaHvMtvlIidq5IiLXZFYOkbuxZ1I1y3BYX4ifF3p0DMYumYHzTN1OzUX1XmVh/t6ounC511ZmYjgOnatBrcYgmSF+Xvh+5iDERRq+U1Nc3oCx7+aq9QZT9FIL9vfS6kWlSjPR2lAZjQHdIiEE1Eo0OFJirKmJysYub8/eaERkOVZPqgaA1tZWHD9+HCUlJWhtVe/TPHjwYHM26bAcoXRHYVk9Zq7Yp1UygrT1TQjHxaYWHDxbY7AwrYcEDEyOxrLpmWrlGh78bK9RI3tLAJJjgvDR5Aw88+3vWqUMPCUJ6QlheGhYMhIjAzH+ve2y3drDA7yR94/rTTrOnGOl2HeqEunx4co7Q3K9qCQA8RH+CPH3xh9naw32sDKUJGvvO0NyTG2fMWUpXKmLPJG7slrpDoVffvkFkyZNwsmTJ7VyWFyxuKsjEELgoI6yEaTOUP0wVa0CWqUETClzIgAcK6lDcUWDzrIXu4sqkRgZiFPl9TrH+KlsaFLWQDPWoJRoteV1lVMQAE5WXABwQbZ9mqUj5MopOHqJBVPbZ05ZCluV2SAi+zArh2jGjBnIyMjAwYMHUVFRgcrKSuUPR6m2DvYmsy7VHkbmlDkxpnyGoe3KlRkxRXuuEXv3GHMkjtIbjYhsy6w7RMeOHcPXX3+tNQ4RWU97h8on/VR7GBnqoSWnY4if3vmeUtujK30M9TDTpFl+oj3XCHtYXebovdFsXXaEyF2YFRBde+21OH78OAMiG0qKDsKAbpEsxWGE/kltY2GpJgLrosgLUf1iUfTkMlTCQpWuwRI9JCDU3xuTP96td31jepgp6Ev4HZwSrTP3BYDOefxivUzRG83RzhUTvYmsy6xHZjNnzsScOXOwdOlS7N27F7/99pvaD1kH+wMaR5LafuSE+at/cWQlR2FxdprWcuseHqize7spPCQJ1QYCK0UPMWPNWpGP7cfL1KZtP16GmSvysDg7TRn8KCiOUd88UueI50rf605E7WdWLzMPD+04SpIkCCFcMqnaEXqZmVNageQtn56J5lZh1COHnGOlWL3vDNbknbF4O6YOSMDwKzqYlEhtbPkJfb2oHL3HmCNxlHPlKGVHiJyN1XuZFRYWmtUwMh+Tqi2nuVVgWGqMUcsOSolud7KzLkNSY0wKhgDjEn4VPah0fUE6eo8xR+Io58rY152IzGdWQJSQkGDpdpABTKq2HFOTYs1JsrZGOwDHT/gl6+DrTmR9RgdE69atww033ABvb2+sW7dO77Jjx45td8PosqqGS3h23R/2boZT8JSArOS2uy6WSoo1J8lasb8Qfy/UXGi2WHKuoyb8knXxdSeyPqNziDw8PHD+/HnExMTI5hApN8gcIouTGzWX5IUHeGPL3GEAYFJJB0PkymUYMjglGi/e2gsL1h60aM8gU8tVkGvg605kOpuU7nAn9gyI3DWZ+olRqThaUgtvDw80tbYiq1sUMhIj8GtBOUrrLmLR+mM611VNMLV0UqxquYwu4QHKbQNQlv2QS9i2RnKuoyT8km3xdScyntWTqgFg06ZN2LRpk1YtM0mSsGTJEnM3SxrcNZn6itgQPDRMe5yrrlGB2HykRO+6qgmmlk6K1SyXobptffuxRnKuoyT8km3xdSeyDrMCoueeew7//Oc/kZGRgU6dOkHSNegLtZu7JlPrSxJlgikREVmaWQHRBx98gKVLl+Kee+6xdHtIRq/YEBw861qFXSUAgb6eaGhsQavKdGOSRHUlmHoAGJgSzb+eiYjIZGaNVH3p0iUMGDDA0m0hFVUNlzB5yS5ct2irywVDQFsF9jqNYAgwfjTgxdlpyOwaoTatFUBza6vBkaGJiIg0mRUQ3Xffffjiiy8s3RZSITdMv6vykIBenUOwee5QLJueaVSPmdAAb3h7esBD42ntrwUVLGVAREQmM/qR2ezZs5X/b21txUcffYSNGzeiT58+8PZW/wJ7/fXXLddCN1RQWqfWtdbVtQrg4BnT7oLpOkctQmDbsVIUlnHkXiIiMp7RAVFenvpf3VdffTUA4ODBg2rTmWDdfu7as8yU8gMsZUBERJZkdEC0efNma7aDVJj1HNMF/HG2GgdOV6Gi/pLBoqeO1tOsoLQOJysa1MaGkZtGpMDrg8ixmD0OEVleVcMlzFqR71aPy1S9+r+jyv8v3XESof5e+O8jgxAXqR38OEopA7nXbEC3SAgB7CwoV07jiMKkIHfN8Pogsj93vRnhkNwpkdoY1ReaMfbdXJ3zF2enISs5Sm2asb3ULEXuNdtxolwtGALa6qox2ZsA+WuG1weR/fEOkYNwt0RqY1U2NCHnWKns47PQAG8sm55pt1IGprxmTPYmgJ0BiBwZ7xA5CHdNpDbGvlOVeud3jQrEsNQYm3+RmPOaFZXXW6El5CyM6QxARPbBgMhBuGuJDmOkx4fbuwmyzHnNWFbEvTlaZwAiuowBkZ0VlNZhxa6T+LWwAn0Tw+HJYQvU+Ht7YN+pSuT89ZihoLQOm4+UoLDs8l/SctNsQZHYbcxr5ilJGOwiZUXMOd+Wfo3s9Zq3l65rxpWuDyJnJQmh0kXHxpqamrBt2zb89NNP2LJlC44dO4b6+npERkYiMzMTDzzwAG688Uad62/cuBGvv/46du3ahfr6eiQkJGDChAmYP38+goKCLNbOmpoahIaGorq6GiEhIRbZZlXDJTz0+T7sOFFueGECAHh5SGhuvXy59k+KhCRB7RzaurdOdUMTZq7Ic4teZub0jrJ0jypX6KEld8042zEQOQtTvr/tGhBt3LgRI0eOBAB07NgR11xzDQIDA/HHH38oB3y8//778cEHH2gN+PjGG29g9uzZkCQJgwYNQocOHZCTk4Pz588jNTUVubm5iIqK0tqnOawREE1esotJ1Fag6Ha/bHqmTfcrl9htr2Rva5m8ZJfOYQ50nW9z1rF0GxyVq10fRI7IlO9vuz4y8/DwwIQJE7Bt2zacO3cO//3vf/Hll1/iwIEDWLlyJTw9PfHRRx9h+fLlauvl5eVhzpw58PT0xPfff4+tW7fiq6++wokTJzB8+HAcOXIEM2bMsNNRGcYeZdaj2lvHluQSu+2V7G0Nimu2RePvJ33n25x1LN0GR+ZK1weRK7BrQHTdddfh66+/xqBBg7Tm3XHHHZg6dSoAYNmyZWrzFi5cCCEEpk2bhhtuuEE5PSAgAEuWLIGHhwe++eYbHD582KrtNxd7lFkfe+tYljm9oyzdo4o9tIjImhw6qTotrW2AveLiYuW0S5cu4fvvvwcATJo0SWudhIQEZGVlAQDWrFljg1aajj3KrO/A6Wqs3HXK6e4aOCpzekdZukcVe2gRkTU5dEB07NgxAECnTp2U044ePYqGhra/FDMyMmTXU0zXLEjrKBQ9Tch6Xt9wFPNWH8Cw17Zg0r9/QXVDk72b5NTM6R1l6R5V7KFFRNbksAHR+fPnsXTpUgDAhAkTlNMLCwsBAGFhYQgODpZdNy4uTm1ZR7Q4Ow0DukXauxlOrX9SpFHncMeJcpZFsABzSqVYuryKI5RrISLX5JClO5qbm3H33XejuroavXv3xgMPPKCcV1tbCwAIDNT916Ciy31NTY1Z+29sbERjY6Pyd3O3o09ogDe++L9+KCyrx68F5fj5UAnWH/rT4vtxVcunZyrLeRSW1eOXgjLMX31Q5/Isi9B+5pRKsXR5FXuXayEi1+WQAdGMGTOwadMmREZG4uuvv4aPj49N979w4UI899xzNtlX16i2D/Rv88/YZH+uQnU8oq5RgUYl1BaVMyCyBMU1a+11bLk9IiKHe2T26KOPYsmSJQgPD8eGDRvQvXt3tfmKx2T19bq/AOvq6gDA7DGD5s+fj+rqauWPalK3tWR1s8yYSe5CM4HWmER1Jt0SEZEuDhUQzZkzB2+//TbCwsKwfv16ZS8zVYmJiQCAqqoq5eMzTYoARrGsqXx9fRESEqL2Y22PDE+x+j5chVwCraFEdSbdEhGRPg4TED3xxBN4/fXXERoaivXr1+vsQZaamoqAgLa7AXv27JFdRjE9PT3dOo21kiWTr7F3ExxeZmKEzgTaxdlp6J+knWQ9oFskk26JiEgvh8ghmjdvHl599VWEhoZiw4YN6Nu3r85lfXx8cOONN2LVqlX44osvMGzYMLX5J0+exI4dOwAA48aNs2q7Le3Tnafs3QS7kKS2yLxFpohMkK8nbrumC6KCfHFjn1i9d3lCA7yx4v5+fyVZl0MCcG1SJO8MERGRQXYPiJ5++mm8/PLLysdk+oIhhXnz5uHrr7/GJ598ggkTJmD06NEAgIaGBkyfPh0tLS2YMGECevToYe3mW4w7l/MQAmjRMa+usQXDr+ig7FFmDCbcEhGRqewaEK1btw4vvvgiACA5ORnvvvuu7HJRUVF47bXXlL+np6dj0aJFmD17NsaMGYMhQ4YgJiYGOTk5OHfuHFJTU/HBBx/Y5BgsheU8dNt3qtKkgIiIiMhUdg2IKioqlP/fs2ePzpyghIQEtYAIAB5//HH07t0bixYtwq5du1BfX4/4+HjMnz8f8+fP1zlooyMqKK3D+eqL9m6Gw0qPD7d3EwwqKK3DyYoGjotDROSkJCGETOYGqaqpqUFoaCiqq6st2uOsquESZq3Id9tHZaq8PIDmVu3p4QHeyPvH9bZvkJHkXsPBKdFYnJ2G0ABvO7aMiIhM+f52mF5m7mjWinxsP15m72Y4hD6dwxCuEUCEB3hj3cMD7dQi48i9htuPl7FUCBGRk7F7UrW7cqck6kHJkcjoGoFDZ2vw0+/y5Un2FVdh89yhOF3ZgH2nKpEeH+7weUO6XsMWIVgqhIjIyTAgshN3SqK+d1AShqXGYPOREp0BEdBWWmNYaozDB0IKhl5DlgohInIefGRmJ8aUmnAVipIZho7Z2UpruNrxEBG5MwZEdhIR6INgX097N8MiNHN/VA3odnlgREV5DU9JUlvGU5KcsrSGqx0PEZE7Y0BkJ7NW5KO2UddwhM4jxM8L1Q1NOudr9mFcnJ2GrGT1QrZZyVFOW1rD1Y6HiMhdsdu9ESzd7b6gtA7XLdpqgZbZ19+u745X1x81uNzmuUO17pYUltWjqLzeZcbtcbXjISJyBaZ8fzOp2g5cJaH6WGmdUcvJJRe7WnkNVzseIiJ3w0dmduAqCdUDZCrLy2FyMREROToGRHagSMZ1ZuEB3shIjECv2BBIOpZhcjERETkLBkR20rNTkL2bYDZPCUiMCMB1i7bi4Nka6EpCY3IxERE5C+YQ2cn72wrt3QSztQgg73S13mX6JoRj2fRMG7WIiIiofXiHyA7Gv5Nr7yZY3e6TlSgsq7d3M4iIiIzCgMgODv1Za+8m2ERROQMiIiJyDgyI7OCKDsH2boJNWKp3WUFpHTYfKeEdJyIishrmENnB6kcGInHe9/ZuhlVZondZVcMlzFqRr1ZRfnBKNBZnpyFUT7kQIiIiU/EOkZ04exkzT1197QH0T4q0SO+yWSvysf14mdq07cfLMHNFXru3TUREpIp3iOxg65ESOHsZsxYBvHpbH0QF+8LLQ8KZygsQAPolRVpk3KGC0jq1O0OX9yuw7VgpCsu0R78mIiIyFwMiO8g/XWXvJljE2eoLmJgRZ5VtGypvIlcOhIiIyFx8ZGYHV3cJs3cTLCI9Ptxq2zZU3oTlQIiIyJIYENnBkNQYhDtoUvDglGgMTomGp6QnSQhtpTsGWbH8iKK8iWY7WA6EiIisgQGRnXw2/Vp7N0FLenwYFmenYXF2GrKSo3QuF+bvjXUPD7R6e+TawXIgRERkDcwhspOXfzpi7yao8QAQ5Out7M6+bHomCsvqUVReDy8PCfnFVaiou4Trroix6p0hVaEB3mrtSIwM5J0hIiKyCgZEdqCrB5U9tQJavbe6Rl0OQGwVBMlRbQcREZE18JGZHRjqQWVPLLdBRETuiAGRHRjqQWVPnhJYJoOIiNwOH5nZQVJ0EAZ0i8SOE+X2booaLw8Jkz/erfydZTKIiMhd8A6RnQhh3e176O81L6u5Vb1RLJNBRETugneI7KCgtA47C6x3d2j59EwMSolGzrFSrNl3BgAwLr0zuoQHoKi8HqU1jXjim98MbodlMoiIyF0wILIDaydVK+70DEqJ1uod1jUqEJuPlJi0PZbJICIiV8dHZnZg7aRqT0nSmxht6v5ZJoOIiFwd7xDZgaIshbXGIpr88S7l/+USoyMCfRAe4I3Khia92/GUJGQlR/HuEBERuTzeIbKTxdlp6J8UafX9yCVGz1qRj2qZYMhLIxObZTKIiMhd8A6RnYQGeGPF/f3w5e5TePKbA1bbj2ZitL5RsptbBZZPz0Rzq2CZDCIiciu8Q2Rn52su2mQ/ihGoDSV0N7cKDEuNYTBERERuhQGRnV3dJcwm+1EkRhtKqGYCNRERuSMGRHY2JDUG4VYcCdpTkjA4JVp5x0eR0O0pSXqXIyIicid2D4iOHDmCxYsXY+rUqejduze8vLwgSRJeeOEFg+tu3LgRY8aMQVRUFPz9/dGjRw8sWLAAdXV1Nmi55Xw2PVMrodlS5BKjF2enISs5yuByRERE7sLuSdXvv/8+3nrrLZPXe+ONNzB79mxIkoRBgwahQ4cOyMnJwUsvvYRvvvkGubm5iIqKMrwhB/DyT0fbVcrDx1NCU6tQ24aHBFyTEI5l0zO1lg8N8May6ZkoLKtHUXk9E6iJiMjt2f0OUa9evTB37lx8/vnnOHToEO655x6D6+Tl5WHOnDnw9PTE999/j61bt+Krr77CiRMnMHz4cBw5cgQzZsywQevbT9Hrq6UdEdGlFqEVULUKYHdRpd6q9V2jAplATUREBAe4Q3Tfffep/e7hYThGW7hwIYQQmDZtGm644Qbl9ICAACxZsgRJSUn45ptvcPjwYfTo0cPibbYka5fxYNkNIiIiw+x+h8hUly5dwvfffw8AmDRpktb8hIQEZGVlAQDWrFlj07aZw/plPKC3jAcRERE5wB0iUx09ehQNDW13VTIyMmSXycjIQE5ODvLy8mTnO5Kk6CD0T4rEzoJys9b3lCSE+Huh5kKz2mM3TwkI8ffG5I93K6fJlfEgIiIiJ7xDVFhYCAAICwtDcHCw7DJxcXFqyzo6qR0dzLKSo7Du4YFavcZC/L21ynPIlfEgIiIiJ7xDVFtbCwAIDNSdFxMUFAQAqKmpMWsfjY2NaGxsVP5u7naMUVBahx0nzLs7tHx6JgalRAOAWq8xTwlqd4YUNMt4EBERURunu0NkCwsXLkRoaKjyR3HHyRrak1Td3KretUzRa6zFQIc1RRkPIiIiauN0AZHiMVl9ve4vdcXAjCEhIWbtY/78+aiurlb+FBcXm7UdY7QnqVpXmQ2W5yAiIjKN0wVEiYmJAICqqirl4zNNigBGsaypfH19ERISovZjLbpKaXgA6BUbgr4J4WaV2ejVOQSag1+zPAcREZE8pwuIUlNTERDQdgdkz549sssopqenp9usXe3xwq09EeKvns7VCuDg2RrsPlmpNU9XmY2qhkuYvGQXrlu0FQfP1EDjiRrLcxAREengdEnVPj4+uPHGG7Fq1Sp88cUXGDZsmNr8kydPYseOHQCAcePG2aOJJnt67e+oudCsc37NhWb0TQzHQ8OS9ZbZmLUiH9uPl6lN8wBwZWwIFk9K550hIiIiHZzuDhEAzJs3D5Ik4ZNPPsFPP/2knN7Q0IDp06ejpaUFEyZMcPhRqgHjSne0CIHdRZV6gyFd21HcaSIiIiLd7H6HaN++fXjooYeUv584cQIA8OGHH+K///2vcvqaNWvQqVMnAG2PwhYtWoTZs2djzJgxGDJkCGJiYpCTk4Nz584hNTUVH3zwgW0PxEym9DLTV4bD0HZYwoOIiEg3uwdENTU1+PXXX7Wmnz59GqdPn1b+rjouEAA8/vjj6N27NxYtWoRdu3ahvr4e8fHxmD9/PubPn69z0EZHY0ovM329wwzd6mPPMiIiIt3sHhANHToUwsxK7yNGjMCIESMs3CLbUvQy2368TO9jswHdImXv8FQ1XMJDn+/TObijpyQhKzmKd4eIiIj0cMocIlezODtNq/SGJl2x0qwV+XpHumbPMiIiIsMYEDmA0ABvLJueiWX3ZupcZmdBuVbFekUitT7P3dKTxVyJiIgMYEDkQPQ9MgO0S24Yk5DNMh1ERESGMSByIKaW3DAmIZvJ1ERERIYxIHIw+kpuCCGw+UiJ8tGZIiFbF5bpICIiMo4kzO3i5UZqamoQGhqK6upqq9Q1q2q4hFkr8nXmAw3oFgkh2vKIFAanRCuTpR/8fK9WYnX/pEh8cPc1zB8iIiK3Zcr3NwMiI1g7IJq8ZJdWt3vVkhvPfPu71nxFd/pl09sSsQvL6vFrQTkEgH5J8l30iYiI3Ikp3992H4fI3enqKaYouVFcUS87v0UIbDtWisKythGoFT9ERERkOuYQ2ZmhnmJ5xVV657MXGRERUfvxDpGdGeop1inET+981V5kBaV1OFnRoLcILBEREWljQGRnhkp3PPHNAYQHeKO6oQmtKtNVS3LIJWUrkq6ZVE1ERGQYH5k5AEOlO2ouNGkFNqolOWatyMf242Vq87cfL8PMFXmWbywREZEL4h0iB6Ao3bHtaAkmf7xba36LACobmrB8eiaaW4XaIzFdSdmaSddERESkG+8QOZAWAwMgNLcKDEuNUQtwDCVlM+maiIjIMAZEDsTU0h3mrkNERETqGBA5EEWCtaekXrtDUbpD7tGXOesQERGROgZEDkYuwVo1gdpS6xAREdFlLN1hBGuX7pBTWFaPovJ6k8YUMmcdIiIiV8XSHS7AnFIcLN9BRERkHj4yIyIiIrfHgIiIiIjcHgMiIiIicnsMiIiIiMjtMSAiIiIit8eAiIiIiNweAyIiIiJyewyIiIiIyO0xICIiIiK3x4CIiIiI3B4DIiIiInJ7DIiIiIjI7bG4KxmloLQOJysakBjJArJEROR6GBCRXlUNlzBrRT62HStVThucEo3F2WkIDfC2Y8uIiIgsh4/MSK9ZK/Kx/XiZ2rTtx8swc0WenVpERERkeQyISKeC0jpsO1aKFiHUprcIgW3HSlFYVm+nlhEREVkWAyLS6WRFg975ReUMiIiIyDUwICKdEiIC9M5PjGRyNRERuQYGRKRTUnQQBqdEw1OS1KZ7ShIGp0SztxkREbkMpw+IVq1ahaFDhyI8PByBgYG46qqr8Morr6CpqcneTXMJi7PTkJUcpTYtKzkKi7PT7NQiIiIiy5OE0MiYdSKPPfYY3nrrLXh5eeG6665DUFAQfv75Z1RVVWHgwIFYv349/P39272fmpoahIaGorq6GiEhIRZoufMpLKtHUXk9xyEiIiKnYcr3t9OOQ7R27Vq89dZbCAoKwtatW5Geng4AKCsrw3XXXYfc3Fz8/e9/x2uvvWbnlrqGrlEMhIiIyHU57SOzl156CQAwb948ZTAEAFFRUXjvvfcAAO+88w6qq6vt0j4iIiJyHk4ZEJ05cwa7d+8GAEyaNElr/sCBAxEXF4fGxkb88MMPtm4eERERORmnDIjy8tpGSY6IiEDXrl1ll8nIyFBbloiIiEgXpwyICgsLAQDx8fE6l4mLi1NbloiIiEgXp0yqrq2tBQAEBupO8g0KCgLQlmFuqsbGRjQ2Nip/N2cbRERE5Dyc8g6RtS1cuBChoaHKH8XdJiIiInJNThkQBQcHAwDq63XX0qqrqwMAs8YNmj9/Pqqrq5U/xcXF5jWUiIiInIJTPjJLTEwEAL2BimKeYllT+Pr6wtfX15ymERERkRNyyjtEaWltZSPKy8t1Jk3v2bMHANTGKCIiIiKS45R3iLp06YK+ffti9+7d+OKLL7BgwQK1+bm5uSguLoavry/GjBnT7v0pqpswuZqIiMh5KL63japSJpzUmjVrBAARFBQk9u7dq5xeVlYmevfuLQCIOXPmWGRfxcXFAgB/+MMf/vCHP/xxwp/i4mKD3/VOXdz10Ucfxdtvvw1vb28MHz4cgYGB2LRpE6qqqpCVlYUNGzZYpLhra2srzp49i+DgYEiSZPL6NTU1iIuLQ3FxsdsWh7UEnkfL4HlsP55Dy+B5tAyeR92EEKitrUVsbCw8PPRnCTnlIzOFt956C1lZWXj33XexY8cONDU1oVu3bpg3bx4ef/xx+Pj4WGQ/Hh4e6NKlS7u3ExISwovVAngeLYPnsf14Di2D59EyeB7lhYaGGrWcUwdEAHD77bfj9ttvt3cziIiIyIk5ZS8zIiIiIktiQGQDvr6+eOaZZzi2UTvxPFoGz2P78RxaBs+jZfA8WoZTJ1UTERERWQLvEBEREZHbY0BEREREbo8BEREREbk9BkRERETk9hgQERERkdtjQERERERujwERERERuT0GREREROT2GBARERGR22NARERERG6PAZGVrVq1CkOHDkV4eDgCAwNx1VVX4ZVXXkFTU5O9m+YQpk6dCkmS9P5cvHhRdt29e/di4sSJ6NChA/z8/NC1a1fMnDkTJSUlNj4K2zhy5AgWL16MqVOnonfv3vDy8oIkSXjhhRcMrrtx40aMGTMGUVFR8Pf3R48ePbBgwQLU1dXpXe/48eOYOnUqunTpAl9fX3Tp0gVTp05FQUGBpQ7Lpsw5h88++6zBa/Tw4cM613e1c9jU1IRNmzbhb3/7G/r27YuwsDB4e3ujY8eOGDt2LL7//nu96/NabGPueeT1aEWCrObRRx8VAISXl5e4/vrrxfjx40VYWJgAIAYOHCgaGhrs3US7mzJligAgsrKyxJQpU2R/Ll26pLXeqlWrhJeXlwAg+vbtK26//XaRlJQkAIgOHTqIY8eO2eForEtxPWn+PP/883rXe/311wUAIUmSGDx4sJg4caLo2LGjACBSU1NFaWmp7Hq5ubkiICBAABA9e/YUd9xxh+jZs6cAIAIDA8XOnTutcZhWZc45fOaZZwQAcdVVV+m8Rs+ePSu7riueww0bNijPW8eOHcWNN94obr/9dtGrVy/l9Pvvv1+0trZqrctr8TJzzyOvR+thQGQla9asEQBEUFCQ2Lt3r3J6aWmp6N27twAg5syZY8cWOgZFQPTJJ58Yvc6ZM2eUb+oPP/xQOb25uVncfffdyiBJ7gPZmf373/8Wc+fOFZ9//rk4dOiQuOeeewx+me/bt09IkiQ8PT3FDz/8oJxeX18vhg8fLgCICRMmaK1XX18vYmNjBQAxf/58tXnz588XAERcXJzTBfXmnEPFF9Azzzxj0r5c9Rxu2rRJTJgwQWzbtk1r3sqVK4Wnp6cAID799FO1ebwW1Zl7Hnk9Wg8DIivp27evACBeeOEFrXk5OTkCgPD19RVVVVV2aJ3jMCcg+tvf/iYAiBEjRmjNq62tFaGhoQKA+OmnnyzYUsejOHf6vswnTpwoAIj77rtPa15RUZHw8PAQAMShQ4fU5r377rsCgOjevbtoaWlRm9fS0iK6d+8uAIgPPvjAMgdjJ8acQ3O/gNzlHGqaPn26ACCGDx+uNp3Xoml0nUdej9bDHCIrOHPmDHbv3g0AmDRpktb8gQMHIi4uDo2Njfjhhx9s3Tynt2bNGgDy5zYoKAhjx44FAKxevdqm7XI0ly5dUuYhyJ2rhIQEZGVlAbh8ThUUv995553w8FD/mPDw8MAdd9wBgOdYH3c9h2lpaQCA4uJi5TRei6aTO4/t4a7n0RRe9m6AK8rLywMAREREoGvXrrLLZGRkoLi4GHl5ecjOzrZl8xzS5s2bceDAAdTW1iIyMhKZmZkYM2YMfH191Zarra3F8ePHAbSdQzkZGRlYvny58nVwV0ePHkVDQwMA/ecqJydH61wpfte3nupy7mDfvn2YN28eKioqEBoairS0NNx8880IDg6WXd5dz+GxY8cAAJ06dVJO47VoOrnzqIrXo+UxILKCwsJCAEB8fLzOZeLi4tSWdXfLli3TmtapUyd8/PHHGD16tHJaUVGR8v+6zi/PbRvF8YeFhen8kJQ7V7W1tSgvLwdg+ByXlpaivr4egYGBFmu3o/ruu+/w3XffqU0LDQ3F22+/jcmTJ6tNd9dzeP78eSxduhQAMGHCBOV0Xoum0XUeVfF6tDw+MrOC2tpaANB7QQUFBQEAampqbNImR3XVVVfhrbfewsGDB1FTU4M///wT69evx4ABA3Du3DmMHTsWW7ZsUS6vOLeA7vPLc9vG3OvQlHOsua4r6tatG1566SXk5eWhoqICFRUVyM3NxU033YTq6mpMmTIFn3/+udo67ngOm5ubcffdd6O6uhq9e/fGAw88oJzHa9F4+s4jwOvRmniHiOzq8ccfV/s9ODgYI0eOxIgRIzBu3Dh8++23eOyxx5Cfn2+fBpLbu+eee7SmZWVl4bvvvsOsWbOwePFiPP7445g4cSJ8fHzs0ELHMGPGDGzatAmRkZH4+uuv3fpctIeh88jr0Xp4h8gKFLeE6+vrdS6jGIQsJCTEJm1yNpIk4bnnngMA7N+/X5lYqHq7Xdf55bltY+51aMo51lzX3Tz77LPw9PREaWkpfv31V+V0dzuHjz76KJYsWYLw8HBs2LAB3bt3V5vPa9E4hs6jIbwe24cBkRUkJiYC0N87QDFPsSxpu+KKK5T/P336NIC23igKp06dkl2P57aN4virqqrUbpmrkjtXwcHBiIiIAGD4HEdFRbllroFCREQEYmJiAFy+RgH3Oodz5szB22+/jbCwMKxfv17ZO0oVr0XDjDmPhvB6bB8GRFaguJDLy8t1Jvbu2bMHAJCenm6zdjkbRRIgcPkvnJCQECQnJwO4fA418dy2SU1NRUBAAADTz5Xid55j/VpaWlBdXQ0AWsnC7nAOn3jiCbz++usIDQ3F+vXrdfZg4rWon7Hn0RB3vx7biwGRFXTp0gV9+/YFAHzxxRda83Nzc1FcXAxfX1+MGTPG1s1zGitXrgTQFgSlpqYqp48bNw6A/Lmtq6tT9rwYP368DVrpuHx8fHDjjTcCkD9XJ0+exI4dOwBcPqcKit9XrlyJ1tZWtXmtra348ssvAfAcr1u3Dg0NDZAkSetLzNXP4bx58/Dqq68iNDQUGzZsUH7myeG1qJsp59EQd74eLcLeI0O6Kl2lO8rKyli64y95eXni22+/FU1NTWrTW1paxH/+8x/h5+cnAIinn35abb5q6Y6PPvpIOb25uVlZisEVS3doMmaU5b179yrLJfz444/K6aaUS3jqqafU5j311FMCgOjSpYvTD/Nv6ByePHlSLF++XFy4cEFr3po1a0RERIQAIO6++26t+a58DhcsWCAAiLCwMLFr1y6j1uG1qM3U88jr0bokIYSwaQTmRh599FG8/fbb8Pb2xvDhwxEYGIhNmzahqqoKWVlZ2LBhA/z9/e3dTLtZu3Ytxo0bh/DwcKSnp6NDhw6oqqrCwYMHlc+5s7OzsWzZMnh5qXeIXLVqFbKzs9HS0oJrr70WiYmJ2L17NwoKCtChQwfk5uYqH625in379uGhhx5S/n7ixAmUlZWhS5cu6Ny5s3L6mjVr1AZze+ONNzB79mxIkoQhQ4YgJiYGOTk5OHfuHFJTU5Gbm4uoqCit/W3fvh3XX389Ghoa0KtXL/Tq1QsHDx7EwYMHERgYiI0bN6Jfv37WPWgLM/Uc5ufnIy0tDUFBQUhLS0Pnzp1x4cIF/PHHH8qB84YNG4Z169apdVtWcMVzuG7dOtxyyy0A2gbz69mzp+xyUVFReO2119Sm8Vq8zJzzyOvRyuwdkbm6L7/8UgwePFiEhIQIf39/0atXL/Gvf/1LNDY22rtpdldQUCAee+wxMXDgQNG5c2fh5+cnfH19RXx8vLjtttvE999/r3f9PXv2iPHjx4vo6Gjh4+MjEhISxMMPPyzOnz9voyOwrc2bN8tWatf8KSws1Fp3w4YNYvTo0SIiIkL4+vqKlJQUMX/+fFFTU6N3n8eOHROTJ08WsbGxwtvbW8TGxorJkyeL48ePW+korcvUc1hWViaefPJJcd1114n4+HgRGBgovL29RadOncRNN90kvvjiC626UJpc7Rx+8sknRp3DhIQE2fV5LbYx5zzyerQu3iEiIiIit8ekaiIiInJ7DIiIiIjI7TEgIiIiIrfHgIiIiIjcHgMiIiIicnsMiIiIiMjtMSAiIiIit8eAiIiIiNweAyIickuJiYl48803jV6+qKgIkiQhPz/fam0iIvthQEREbmn37t24//77LbrNpUuXIiwszKLbJCLb8DK8CBGR64mOjrZ3E4jIgfAOERE5hf/+978ICwtDS0sLgLbK35IkYd68ecpl7rvvPtx9990AgNzcXAwaNAj+/v6Ii4vDrFmzUF9fr1xW85HZ4cOHMXDgQPj5+eHKK6/Exo0bIUkS1q5dq9aOgoICDBs2DAEBAbjqqquwc+dOAMCWLVswbdo0VFdXQ5IkSJKEZ5991jong4gsjgERETmFQYMGoba2Fnl5eQCArVu3IioqClu2bFEus3XrVgwdOhQnTpzA6NGjMWHCBPz222/48ssvkZubi0ceeUR22y0tLbj11lsREBCAX3/9FR999BEWLFggu+yCBQswd+5c5Ofno3v37sjOzkZzczMGDBiAN998EyEhITh37hzOnTuHuXPnWvw8EJF1MCAiIqcQGhqKq6++WhkAbdmyBY8//jjy8vJQV1eHM2fO4Pjx4xgyZAgWLlyIu+66C4899hhSUlIwYMAAvP3221i2bBkuXryote0NGzbgxIkTWLZsGa666ioMHDgQL774omw75s6dixtvvBHdu3fHc889h5MnT+L48ePw8fFBaGgoJElCx44d0bFjRwQFBVnzlBCRBTEgIiKnMWTIEGzZsgVCCOTk5GD8+PG44oorkJubi61btyI2NhYpKSnYv38/li5diqCgIOXPqFGj0NraisLCQq3tHjlyBHFxcejYsaNyWmZmpmwb+vTpo/x/p06dAAAlJSUWPlIisjUmVROR0xg6dCg+/vhj7N+/H97e3ujRoweGDh2KLVu2oLKyEkOGDAEA1NXV4YEHHsCsWbO0thEfH9+uNnh7eyv/L0kSAKC1tbVd2yQi+2NAREROQ5FH9MYbbyiDn6FDh+Jf//oXKisrMWfOHABAeno6/vjjDyQnJxu13dTUVBQXF+PPP/9Ehw4dALR1yzeVj4+PMumbiJwLH5kRkdMIDw9Hnz598Pnnn2Po0KEAgMGDB2Pfvn04evSoMkh68sknsWPHDjzyyCPIz8/HsWPH8O233+pMqh45ciS6deuGKVOm4LfffsP27dvx9NNPA7h8F8gYiYmJqKurw6ZNm1BWVoaGhob2HTAR2QwDIiJyKkOGDEFLS4syIIqIiMCVV16Jjh07IjU1FUBbns/WrVtx9OhRDBo0CGlpafjHP/6B2NhY2W16enpi7dq1qKurQ9++fXHfffcpe5n5+fkZ3bYBAwZgxowZuOOOOxAdHY1XXnmlfQdLRDYjCSGEvRtBRORotm/fjoEDB+L48ePo1q2bvZtDRFbGgIiICMCaNWsQFBSElJQUHD9+HI8++ijCw8ORm5tr76YRkQ0wqZqICEBtbS2efPJJnDp1ClFRURgxYgQWLVpk72YRkY3wDhERERG5PSZVExERkdtjQERERERujwERERERuT0GREREROT2GBARERGR22NARERERG6PARERERG5PQZERERE5PYYEBEREZHb+39jnlSVEmDhLQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax1 = plt.subplots() # prepare a matplotlib figure\n", + "\n", + "surveys_df.plot(\"weight\",\"hindfoot_length\", kind=\"scatter\", ax=ax1)\n", + "\n", + "# Provide further adaptations with matplotlib:\n", + "ax1.set_xlabel(\"weight\")\n", + "ax1.tick_params(labelsize=16, pad=8)\n", + "fig.suptitle('Scatter plot of hindfood length versus weight', fontsize=15)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/course_materials/solutions/morning_exercises_solutions.ipynb b/book/solutions/morning_exercises_solutions.ipynb similarity index 62% rename from course_materials/solutions/morning_exercises_solutions.ipynb rename to book/solutions/morning_exercises_solutions.ipynb index 09a4d90..0da205b 100644 --- a/course_materials/solutions/morning_exercises_solutions.ipynb +++ b/book/solutions/morning_exercises_solutions.ipynb @@ -5,13 +5,21 @@ "id": "cac5b58d", "metadata": {}, "source": [ - "#### ---\n", - "title: \"Exercises\"\n", + "---\n", "execute: \n", " enabled: true\n", + " error: true\n", "---" ] }, + { + "cell_type": "markdown", + "id": "f2eba16f", + "metadata": {}, + "source": [ + "# Morning Exercises: Python fundamentals {.unnumbered}" + ] + }, { "cell_type": "markdown", "id": "74ecb0e3-061f-4318-b0c1-eb7eea7b76a8", @@ -24,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "5b2453e4-d68b-49ad-85b1-1d28e94e54a7", "metadata": {}, "outputs": [], @@ -51,10 +59,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "7463ed46-b7c5-4b51-b34a-7c5f3c478283", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the value of x is 6\n", + "the value of apple is apple\n" + ] + } + ], "source": [ "x = 6\n", "apple = \"apple\"\n", @@ -75,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "f6be831f-656e-4eba-96ec-6f8703840617", "metadata": {}, "outputs": [], @@ -85,20 +102,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "27da351a-5246-458f-8391-3ef325ee2f20", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "s > 1" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "76ff08d7-e30e-4b2e-b80f-f3e90598b840", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "1.6" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "round(s, 1)" ] @@ -120,10 +159,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "c3e04e72-a4e7-4599-a8d4-759e4031d7a1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "False\n", + "True\n" + ] + } + ], "source": [ "print(5 == 5)\n", "print(not 3 > 2)\n", @@ -146,30 +196,89 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "20427367-d74a-4e22-9a64-975d46a966cc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], "source": [ "print(1 + 1)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "35bfe887", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], "source": [ "print(1 + True)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "cd1f883f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unexpected exception formatting exception. Falling back to standard exception\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3460, in run_code\n", + " exec(code_obj, self.user_global_ns, self.user_ns)\n", + " File \"/tmp/ipykernel_18646/2622355716.py\", line 1, in \n", + " print(1 + \"one\")\n", + "TypeError: unsupported operand type(s) for +: 'int' and 'str'\n", + "\n", + "During handling of the above exception, another exception occurred:\n", + "\n", + "Traceback (most recent call last):\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2057, in showtraceback\n", + " stb = self.InteractiveTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1288, in structured_traceback\n", + " return FormattedTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1177, in structured_traceback\n", + " return VerboseTB.structured_traceback(\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 1030, in structured_traceback\n", + " formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 935, in format_exception_as_a_whole\n", + " self.get_records(etb, number_of_lines_of_context, tb_offset) if etb else []\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/IPython/core/ultratb.py\", line 987, in get_records\n", + " style = stack_data.style_with_executing_node(style, self._tb_highlight)\n", + " File \"/home/jelle/.local/lib/python3.8/site-packages/stack_data/core.py\", line 455, in style_with_executing_node\n", + " class NewStyle(style):\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 91, in __new__\n", + " ndef[4] = colorformat(styledef[3:])\n", + " File \"/usr/lib/python3/dist-packages/pygments/style.py\", line 58, in colorformat\n", + " assert False, \"wrong color format %r\" % text\n", + "AssertionError: wrong color format 'ansiyellow'\n" + ] + } + ], "source": [ "print(1 + \"one\")" ] @@ -198,10 +307,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "6d12ffce-0492-4b91-88b6-d657bbeffe2f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "average age is 29.75\n" + ] + } + ], "source": [ "name = ['Ann', 'Bob', 'Chloe', 'Dan']\n", "age = [25, 28, 36, 30]\n", @@ -223,30 +340,63 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "2b5a51a0-3c0d-477c-996c-4baf28712025", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "25" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "age[0]" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "f70eb682-14dd-422e-8073-7f18b81c5c3f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['Bob', 'Dan']" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "[name[1], name[3]]" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "a09e1dce-23be-4de5-9e70-6b7d616efed4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[25, 28]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "new_age=[]\n", "for a in age:\n", @@ -263,10 +413,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "0851e7fc-ce66-449a-a9a6-25f4df4363f6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "36" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "age[name.index(\"Chloe\")]" ] @@ -293,7 +454,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "c52f771b-6638-4eee-b55e-e1a643ca9508", "metadata": {}, "outputs": [], @@ -303,17 +464,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "c95ea81a-8281-4951-b13e-562a1b713ae5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "dict_values(['Jill', 39, 'Netherlands'])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "my_dict.values()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "a87bf15a-08c2-4469-ad4d-593bee5593cb", "metadata": {}, "outputs": [], @@ -323,10 +495,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "a8ba22bd-9874-421d-903d-2ea1a56ab37c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "dict_values(['Jill', 24, 'Netherlands'])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "my_dict.values()" ] @@ -343,10 +526,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "dc3bc782-bc32-4314-b1d9-87836eefc2ae", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "odd\n" + ] + } + ], "source": [ "number = 5\n", "\n", @@ -369,7 +560,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "204e89ac-af75-4c99-8caf-cf591b7d037f", "metadata": {}, "outputs": [], @@ -384,10 +575,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "577e90fd-5fe7-4104-a879-1c138e7bd041", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 is odd\n" + ] + } + ], "source": [ "# Run this code to test your function above\n", "number = 5\n", @@ -406,10 +605,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "47cd7a85-97c6-4389-8cc3-995e5dc7c33a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 is odd\n", + "2 is even\n", + "3 is odd\n", + "4 is even\n", + "5 is odd\n", + "6 is even\n", + "7 is odd\n", + "8 is even\n", + "9 is odd\n" + ] + } + ], "source": [ "for number in range(1,10,1):\n", " print(number, \"is\", even_or_odd(number))" @@ -432,11 +647,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", -<<<<<<< HEAD - "version": "3.10.8" -======= "version": "3.10.11" ->>>>>>> main } }, "nbformat": 4, diff --git a/course_materials/afternoon_exercises.ipynb b/course_materials/afternoon_exercises.ipynb index 6d07f60..bffcb9f 100644 --- a/course_materials/afternoon_exercises.ipynb +++ b/course_materials/afternoon_exercises.ipynb @@ -8,8 +8,6 @@ "---\n", "title: \"Working with data\"\n", "format: html\n", - "execute: \n", - " enabled: true\n", "---" ] }, @@ -29,18 +27,18 @@ "id": "fc1fdccb-ac7f-4667-97e9-5c63499693c8", "metadata": {}, "source": [ - "### Exercise 1\n", + "### Exercise 0\n", "\n", "Type the following commands and check the outputs. Can you tell what each command does? What is the difference between commands with and without parenthesis?\n", "\n", - "```python\n", - "surveys_df.shape\n", - "surveys_df.columns\n", - "surveys_df.index\n", - "surveys_df.dtypes\n", - "surveys_df.head()\n", - "surveys_df.tail()\n", - "```" + "`surveys_df.shape` Answer:\n", + "`surveys_df.columns` Answer:\n", + "`surveys_df.index` Answer:\n", + "`surveys_df.dtypes` Answer:\n", + "`surveys_df.head()` Answer:\n", + "`surveys_df.tail()` Answer:\n", + "\n", + "[Course book chapter 5 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/data-science-with-pandas-1.html)" ] }, { @@ -54,7 +52,7 @@ { "cell_type": "code", "execution_count": null, - "id": "95c72b85-8d26-43d8-86f8-09030c0b0c5c", + "id": "18f70271-17df-48c4-9ff5-9458584da7ef", "metadata": {}, "outputs": [], "source": [] @@ -62,7 +60,7 @@ { "cell_type": "code", "execution_count": null, - "id": "18f70271-17df-48c4-9ff5-9458584da7ef", + "id": "230f8bde", "metadata": {}, "outputs": [], "source": [] @@ -96,7 +94,7 @@ "id": "763cd8cc-6fc0-4f55-b1f5-aaf2d35b03ba", "metadata": {}, "source": [ - "### Exercise 2\n", + "### Exercise 1\n", "Perform some basic statistics on the weight column. For practical reasons, it can be useful to first create a variable `weight` that contains the just the weight column. It will make the code look a bit cleaner. Can you tell what each method listed below does? Look at our explorative plot, do the statistics make sense?\n", "\n", "```python\n", @@ -106,7 +104,9 @@ "weight.mean()\n", "weight.std()\n", "weight.counts()\n", - "```" + "```\n", + "\n", + "[Course book chapter 5 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/data-science-with-pandas-1.html)" ] }, { @@ -162,12 +162,12 @@ "id": "2bcb581f", "metadata": {}, "source": [ - "### Exercise 3\n", - "- Swap the order of column names in `surveys_df[['plot_id', 'species_id']]`\n", - "- Repeat one of the column names like `surveys_df[['plot_id', 'plot_id', 'species_id']]`\n", - "What do the results look like and why?\n", - "- Which error occurrs in `surveys_df['plot_id', 'species_id']` and why?\n", - "- Which error occurrs in `surveys_df['speciess']`?" + "### Exercise 2\n", + "- Print the columns 'species_id' and 'plot_id' side by side\n", + "- Do the same, but use one of these columns twice.\n", + "What do the results look like and why? Answer: \n", + "- Which error occurrs in `surveys_df['plot_id', 'species_id']` and why? Answer:\n", + "- Which error occurrs in `surveys_df['speciess']`? Answer:" ] }, { @@ -178,27 +178,62 @@ "outputs": [], "source": [] }, + { + "cell_type": "code", + "execution_count": null, + "id": "a76c904a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f431b19e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "108f548a", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "119b576b", "metadata": {}, "source": [ - "### Exercise 4\n", - "What happens when you call:\n", - "- `surveys_df[0:1]`\n", - "- `surveys_df[:4]`\n", - "- `surveys_df[:-1]`\n", - "\n", + "### Exercise 3\n", "What happens when you call:\n", - "- `surveys_df.iloc[0:4, 1:4]`\n", - "- `surveys_df.loc[0:4, 1:4]`\n", - "How are the two commands different?" + "- `surveys_df[0:1]` Answer:\n", + "- `surveys_df[:4]` Answer: \n", + "- `surveys_df[:-1]` Answer: " ] }, { "cell_type": "code", "execution_count": null, - "id": "bd3b4c74", + "id": "1017c8fe", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5ba4a57", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9a3cd7e6", "metadata": {}, "outputs": [], "source": [] @@ -208,11 +243,13 @@ "id": "4fc54c12", "metadata": {}, "source": [ - "### Exercise 5\n", + "### Exercise 4\n", "What happens in the following two examples?\n", "\n", "- ```surveys_df.iloc[0:4, 1:4]```;\n", - "- ```surveys_df.loc[0:4, 1:4]```.\n" + "- ```surveys_df.loc[0:4, 1:4]```.\n", + "\n", + "How are the two commands different? Answer: " ] }, { @@ -223,13 +260,21 @@ "outputs": [], "source": [] }, + { + "cell_type": "code", + "execution_count": null, + "id": "002ca88a", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "7b12cdaf", "metadata": {}, "source": [ - "### Exercise 6\n", - "- Create a new DataFrame that only contains observations with sex values that are not female or male. Print the number of rows in this new DataFrame. Verify the result by comparing the number of rows in the new DataFrame with the number of rows in the surveys DataFrame where sex is NaN (hint: there is a function `isnull`).\n", + "### Exercise 5\n", + "- Create a new DataFrame that only contains observations from the original DataFrame with sex values that are not female or male. Print the number of rows in this new DataFrame. Verify the result by comparing the number of rows in the new DataFrame with the number of rows in the surveys DataFrame where sex is NaN (hint: there is a function `isnull`).\n", "- Create a new DataFrame that contains only observations that are of sex male or female and where weight values are greater than 0." ] }, @@ -241,15 +286,23 @@ "outputs": [], "source": [] }, + { + "cell_type": "code", + "execution_count": null, + "id": "cdcd971b", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "b34b321b", "metadata": {}, "source": [ - "### Exercise 7: Putting it all together \n", - "1. Clean the column *sex* (leave out samples of which we do not know whether they are male or female)\n", - "2. Create a new dataframe *clean_df* which only contains rows of which we have a valid value for *sex* and *weight*\n", - "3. Calculate the average weight of that new DataFrame" + "### Exercise 6: Putting it all together \n", + "1. Clean the column *sex* (leave out samples of which we do not know whether they are male or female) and save the result as a new dataframe `clean_df`.\n", + "2. Replace undefined *weight* values with the mean of all (defined) weights in `surveys_df`.\n", + "3. Calculate the average weight of that new DataFrame `clean_df`" ] }, { @@ -265,7 +318,7 @@ "id": "ccb33c2e", "metadata": {}, "source": [ - "### Exercise 8\n", + "### Exercise 7\n", "Let's see in which plots animals get more food. Calculate the average weight per plot! Complete the code below." ] }, @@ -285,10 +338,11 @@ "id": "2bccb9da", "metadata": {}, "source": [ - "### Exercise 9\n", - "Investigate the group keys and row indexes for this more complex grouping example. \n", - "Why are there more than 48 groups?\n", - "What happened to the third group and why does it not turn up in our statistics?" + "### Exercise 8\n", + "See below a more complex grouping example. Investigate the group keys and row indexes for this more complex grouping example. \n", + "Why are there more than 48 groups? Answer: \n", + "Calculate the average weight per group.\n", + "What happened to the third group and why does it not turn up in our statistics? Answer:" ] }, { @@ -299,15 +353,23 @@ "outputs": [], "source": [ "grouped_data = surveys_df.groupby(['sex', 'plot_id'])\n", - "len(grouped_data.groups)" + "print(len(grouped_data.groups))" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "7843cd60", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "b0f1ab75", "metadata": {}, "source": [ - "### Exercise 10\n", + "### Exercise 9\n", "Would it make sense to group our data frame by the column *weight*? Why or why not?" ] }, @@ -316,7 +378,7 @@ "id": "0c7ae97d", "metadata": {}, "source": [ - "### Exercise 11\n", + "### Exercise 10\n", "In the given example of vertical concatenation, you concatenated two DataFrames with the same columns. What would happen if the two DataFrames to concatenate have different column number and names?\n", "\n", " 1. Create a new DataFrame using the last 10 rows of the species DataFrame (`species_df`);\n", @@ -341,7 +403,7 @@ "id": "afa7dd9c", "metadata": {}, "source": [ - "### Exercise 12\n", + "### Exercise 11\n", "In the given example of horizontal concatenation, you first concatenated two DataFrame with different indices, then reset the indices of the second one. Based on the outcome of these two cases, try to answer the following questions:\n", " 1. What happens when you concatenate horizontally two DataFrames with different indexing?\n", " 2. What happens when you concatenate horizontally two DataFrames with the same columns?\n", @@ -368,7 +430,7 @@ "tags": [] }, "source": [ - "### Exercise 13\n", + "### Exercise 12\n", "Time to play with plots! Look at the pandas.DataFrame.plot() documentation [here](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.html) and change your data visualization selecting different DataFrame columns, x and y axes, and kind of plot (try at least three different plots).\n" ] }, @@ -379,9 +441,11 @@ "metadata": {}, "outputs": [], "source": [ + "import matplotlib.pyplot as plt\n", + "\n", "fig, ax1 = plt.subplots() # prepare a matplotlib figure\n", "\n", - "surveys.plot(\"hindfoot_length\", \"weight\", kind=\"scatter\", ax=ax1)\n", + "surveys_df.plot(\"hindfoot_length\", \"weight\", kind=\"scatter\", ax=ax1)\n", "\n", "# Provide further adaptations with matplotlib:\n", "ax1.set_xlabel(\"Hindfoot length\")\n", @@ -389,20 +453,12 @@ "fig.suptitle('Scatter plot of weight versus hindfoot length', fontsize=15)" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "d9191732-388d-4b5b-8445-f9cce0375390", - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "id": "aec3890f-9219-456a-9375-692ed307ff43", "metadata": {}, "source": [ - "### Exercise 14 \n", + "### Exercise 13\n", "\n", "Plot the data from different groups in two subplots in a single figure:\n", "- Initialize a Figure with 2 Axes distributed in one rows and two columns;\n", diff --git a/course_materials/empty_notebook_for_coding_along.ipynb b/course_materials/empty_notebook_for_coding_along.ipynb new file mode 100644 index 0000000..08712f7 --- /dev/null +++ b/course_materials/empty_notebook_for_coding_along.ipynb @@ -0,0 +1,92 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6be8c60c-486a-49ec-860d-e8dc361928ad", + "metadata": {}, + "source": [ + "# Code along\n", + "\n", + "Use this notebook to code along during the live coding lectures.\n", + "Use the dedicated exercises notebooks `morning_exercises.ipynb` and `afternoon_exercises.ipynb` for the exercises parts." + ] + }, + { + "cell_type": "markdown", + "id": "c239edb5", + "metadata": {}, + "source": [ + "## Test Installation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d8e35e29-a355-45e7-a693-624f0ee80b2b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.8.10\n", + "1.5.3\n", + "3.6.3\n", + "1.24.1\n", + "No errors! Ready to code!\n" + ] + } + ], + "source": [ + "from platform import python_version\n", + "\n", + "import pandas as pd\n", + "import matplotlib\n", + "import numpy as np\n", + "\n", + "print(python_version())\n", + "print(pd.__version__)\n", + "print(matplotlib.__version__)\n", + "print(np.__version__)\n", + "print(\"No errors! Ready to code!\")" + ] + }, + { + "cell_type": "markdown", + "id": "2d5cbbaf", + "metadata": {}, + "source": [ + "## Code along" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14183541", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/course_materials/morning_exercises.ipynb b/course_materials/morning_exercises.ipynb index 88f49df..9009422 100644 --- a/course_materials/morning_exercises.ipynb +++ b/course_materials/morning_exercises.ipynb @@ -19,12 +19,13 @@ "source": [ "### Exercise 0\n", "\n", - "1. Try to run the code below. Why is there no output? (double click this cell to be able to edit the answer) " + "1. Try to run the code below. Why is there no output? (double the cell with 'Answer:' to edit the answer) \n", + "[Course book chapter 1 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/Introduction_to_python_1.html)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "5b2453e4-d68b-49ad-85b1-1d28e94e54a7", "metadata": {}, "outputs": [], @@ -38,7 +39,7 @@ "id": "ffb712c2-e744-4110-9879-acab825e8caf", "metadata": {}, "source": [ - "Answer: " + "Answer: [DOUBLE CLICK THIS CELL AND ANSWER HERE]" ] }, { @@ -65,7 +66,9 @@ "### Exercise 1\n", "1. Calculate: One plus five divided by nine and assign the result of the calculation to a variable.\n", "2. Test if the result is larger than one. (tip: output of the cell should be True or False)\n", - "3. Round off the result to one decimal. Use the function `round`. (tip: use `? round` or you internet search engine for information about how to use the function)" + "3. Round off the result to one decimal. Use the function `round`. (tip: use `? round` or you internet search engine for information about how to use the function)\n", + "\n", + "[Course book chapter 2 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/Introduction_to_python_2.html)" ] }, { @@ -110,7 +113,9 @@ "`5 == 5` answer: \n", "`not 3 > 2` answer: \n", "`True == 'True'` answer: \n", - "`False < True` answer: \n" + "`False < True` answer: \n", + "\n", + "[Course book chapter 2 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/Introduction_to_python_2.html)" ] }, { @@ -135,7 +140,9 @@ "Evaluate the statements below. What do you think will be the output of python? Do you agree with python? \n", "`1 + 1` answer: \n", "`1 + True` answer: \n", - "`1 + \"one\"` answer: \n" + "`1 + \"one\"` answer: \n", + "\n", + "[Course book chapter 2 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/Introduction_to_python_2.html)" ] }, { @@ -161,7 +168,9 @@ "\n", "2. How old are Ann, Bob, Chloe, and Dan? You decide! Design a numeric list with their respective ages. Save it as \"age\".\n", "\n", - "3. What is their average age? (Use the function `sum` to sum up their cumulative ages, you can use `len(age)` to get the number of elements in a list)" + "3. What is their average age? (Use the function `sum` to sum up their cumulative ages, you can use `len(age)` to get the number of elements in a list)\n", + "\n", + "[Course book chapter 3 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/Introduction_to_python_3.html)" ] }, { @@ -182,7 +191,9 @@ "1. Return only the first number in the list age.\n", "2. Return the 2nd and 4th name in your list name.\n", "3. Return only ages under 30 from your list age. Bonus: put them in a new list called `new_age`.\n", - "4. Return the age of \"Chloe\" from the list age." + "4. Return the age of \"Chloe\" from the list age.\n", + "\n", + "[Course book chapter 3 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/Introduction_to_python_3.html)" ] }, { @@ -226,7 +237,9 @@ "- Create a new dictionary that contains the keys: 'name', 'age' and 'country' and their respective values (you can make up the values yourself).\n", "- Print the values of the dictionary to the screen\n", "- Reassign the value of key 'age' to 24\n", - "- Print the values of the dictionary to the screen again to see if the value has changed." + "- Print the values of the dictionary to the screen again to see if the value has changed.\n", + "\n", + "[Course book chapter 3 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/Introduction_to_python_3.html)" ] }, { @@ -268,7 +281,9 @@ "source": [ "### Exercise 7\n", "Create an if statement that tests whether a number is even or odd, and saves the classification in a variable called `number_class`. \n", - "Hint, you can use the % operator (aka modulo operator). If necessary, you can try the operator to see what it does in the cell below or search the web." + "Hint, you can use the % operator (aka modulo operator). If necessary, you can try the operator to see what it does in the cell below or search the web.\n", + "\n", + "[Course book chapter 3 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/Introduction_to_python_3.html)" ] }, { @@ -289,7 +304,9 @@ "metadata": {}, "source": [ "### Exercise 8\n", - "Turn the if statement from the last exercise into a function e.g. with the name `even_or_odd` (or choose a different name yourself). Let the user provide the value for `number`, and return the `number_class`." + "Turn the if statement from the last exercise into a function e.g. with the name `even_or_odd` (or choose a different name yourself). Let the user provide the value for `number`, and return the `number_class`.\n", + "\n", + "[Course book chapter 4 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/Introduction_to_python_4.html)" ] }, { @@ -319,7 +336,9 @@ "source": [ "### Exercise 9 \n", "Use the function above to determine whether the numbers between 1 and 10 are even or odd. \n", - "Hint: the [`range` function](https://docs.python.org/3.8/library/stdtypes.html#range) might be helpful." + "Hint: the [`range` function](https://docs.python.org/3.8/library/stdtypes.html#range) might be helpful.\n", + "\n", + "[Course book chapter 4 for reference](https://utrechtuniversity.github.io/workshop-introduction-to-python/Introduction_to_python_4.html)" ] }, { @@ -347,7 +366,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.11" + "version": "3.8.12" } }, "nbformat": 4, diff --git a/course_materials/solutions/afternoon_exercises_solutions.ipynb b/course_materials/solutions/afternoon_exercises_solutions.ipynb deleted file mode 100644 index fd526e6..0000000 --- a/course_materials/solutions/afternoon_exercises_solutions.ipynb +++ /dev/null @@ -1,425 +0,0 @@ -{ - "cells": [ - { - "cell_type": "raw", - "id": "14f401b8-2d1d-4a01-a3c8-ed2c59e66d29", - "metadata": {}, - "source": [ - "---\n", - "title: \"Working with data\"\n", - "format: html\n", - "execute: \n", - " enabled: true\n", - "---" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2c6372a4", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "surveys_df = pd.read_csv('../data/surveys.csv')" - ] - }, - { - "cell_type": "markdown", - "id": "507d1c2c-98b8-4a67-b2e5-b3a3031a5b5f", - "metadata": {}, - "source": [ - "### Exercise 1\n", - "\n", - "Type the following commands and check the outputs. Can you tell what each command does? What is the difference between commands with and without parenthesis?\n", - "\n", - "```python\n", - "surveys_df.shape\n", - "surveys_df.columns\n", - "surveys_df.index\n", - "surveys_df.dtypes\n", - "surveys_df.head()\n", - "surveys_df.tail()\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "0514bad4-1266-4553-9752-29dcf3166d21", - "metadata": {}, - "source": [ - "### Exercise 2\n", - "Perform some basic statistics on the weight column. For practical reasons, it can be useful to first create a variable `weight` that contains the just the weight column. It will make the code look a bit cleaner. Can you tell what each method listed below does? Look at our explorative plot, do the statistics make sense?\n", - "\n", - "```python\n", - "weight=surveys_df['weight']\n", - "weight.min()\n", - "weight.max()\n", - "weight.mean()\n", - "weight.std()\n", - "weight.count()\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "2bcb581f", - "metadata": {}, - "source": [ - "### Exercise 3\n", - "- Swap the order of column names in `surveys_df[['plot_id', 'species_id']]`\n", - "- Repeat one of the column names like `surveys_df[['plot_id', 'plot_id', 'species_id']]`.\n", - "What do the results look like and why?\n", - "- Which error occurs in `surveys_df['plot_id', 'species_id']` and why?\n", - "- Which error occurs in `surveys_df['speciess']`?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3731f5fd", - "metadata": {}, - "outputs": [], - "source": [ - "print(surveys_df[['species_id', 'plot_id']])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b71788b1", - "metadata": {}, - "outputs": [], - "source": [ - "surveys_df[['plot_id', 'plot_id', 'species_id']] # repeating column plot_id" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bb68a995", - "metadata": {}, - "outputs": [], - "source": [ - "surveys_df['plot_id', 'species_id'] \n", - "# The tuple, or combination ('plot_id', 'species_id') is not a \n", - "# column name (key) in the dataframe --> KeyError: ('plot_id', 'species_id')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b74edc72", - "metadata": {}, - "outputs": [], - "source": [ - "surveys_df['speciess']\n", - "# 'speciess' is not a column name (key) in the dataframe" - ] - }, - { - "cell_type": "markdown", - "id": "119b576b", - "metadata": {}, - "source": [ - "### Exercise 4\n", - "What happens when you call:\n", - "- `surveys_df[0:1]`\n", - "- `surveys_df[:4]`\n", - "- `surveys_df[:-1]`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bd3b4c74", - "metadata": {}, - "outputs": [], - "source": [ - "surveys_df[0:1] # shows the first row of the dataframe\n", - "surveys_df[:4] # shows the first four rows from index 0 to index 3\n", - "surveys_df[:-1] # shows all rows of the dataframe" - ] - }, - { - "cell_type": "markdown", - "id": "4fc54c12", - "metadata": {}, - "source": [ - "### Exercise 5\n", - "What happens in the following two examples?\n", - "\n", - "- ```surveys_df.iloc[0:4, 1:4]```;\n", - "- ```surveys_df.loc[0:4, 1:4]```.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6680a6fe", - "metadata": {}, - "outputs": [], - "source": [ - "print(surveys_df.iloc[0:4, 1:4])\n", - "surveys_df.loc[0:4, 1:4] # the function loc works with indices for rows (0:4), \n", - "# but not with indices for columns (1:4). COlumns do have names in our dataframe" - ] - }, - { - "cell_type": "markdown", - "id": "7b12cdaf", - "metadata": {}, - "source": [ - "### Exercise 6\n", - "- Create a new DataFrame that only contains observations with sex values that are not female or male. Print the number of rows in this new DataFrame. Verify the result by comparing the number of rows in the new DataFrame with the number of rows in the surveys DataFrame where sex is NaN (hint: there is a function `isnull`).\n", - "- Create a new DataFrame that contains only observations that are of sex male or female and where weight values are greater than 0." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "53f7777a", - "metadata": {}, - "outputs": [], - "source": [ - "df = surveys_df[(surveys_df['sex'].isnull())]\n", - "print(\"Number of rows:\", len(df))\n", - "print(\"Unique values in column 'sex':\", df['sex'].unique())" - ] - }, - { - "cell_type": "markdown", - "id": "b34b321b", - "metadata": {}, - "source": [ - "### Exercise 7: Putting it all together \n", - "1. Clean the column *sex* (leave out samples of which we do not know whether they are male or female) and save the result as a new dataframe `clean_df`.\n", - "2. Fill undefined *weight* values with the mean of all valid weights in `surveys_df`.\n", - "3. Calculate the average weight of that new DataFrame `clean_df`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "570cbd6c", - "metadata": {}, - "outputs": [], - "source": [ - "# Step 1\n", - "# sex is 'F' or 'M'. The `|` means or.\n", - "clean_df = surveys_df[(surveys_df['sex']=='F') | (surveys_df['sex']=='M')]\n", - "# or not sex is null. The `~` means not.\n", - "clean_df = surveys_df[~(surveys_df['sex'].isnull())]\n", - "\n", - "# Step 2\n", - "clean_df.weight.fillna(surveys_df.weight.mean())\n", - "\n", - "# Step 3\n", - "print(\"Average weight of surveys_df:\", surveys_df.weight.mean())\n", - "print(\"Average weight of clean_df:\", clean_df.weight.mean())" - ] - }, - { - "cell_type": "markdown", - "id": "ccb33c2e", - "metadata": {}, - "source": [ - "### Exercise 8\n", - "Let's see in which plots animals get more food. Calculate the average weight per plot! Complete the code below." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "733aba46", - "metadata": {}, - "outputs": [], - "source": [ - "grouped_data = surveys_df.groupby(\"plot_id\")\n", - "grouped_data['weight'].mean()" - ] - }, - { - "cell_type": "markdown", - "id": "2bccb9da", - "metadata": {}, - "source": [ - "### Exercise 9\n", - "Investigate the group keys and row indexes for this more complex grouping example. \n", - "Why are there more than 48 groups?\n", - "What happened to the third group and why does it not turn up in our statistics?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ee674ae9", - "metadata": {}, - "outputs": [], - "source": [ - "grouped_data = surveys_df.groupby(['sex', 'plot_id'])\n", - "print(len(grouped_data.groups))\n", - "grouped_data.groups.keys() # we also have a categorial value 'nan'." - ] - }, - { - "cell_type": "markdown", - "id": "b0f1ab75", - "metadata": {}, - "source": [ - "### Exercise 10\n", - "Would it make sense to group our data frame by the column *weight*? Why or why not?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bbff11b3", - "metadata": {}, - "outputs": [], - "source": [ - "# In real life nearly every sample has a unique value. So nearly every sample would \n", - "# be placed in an own group.\n", - "# In our training data you can see that there are quite some values for weight. So\n", - "# usually it is not a good idea to categorise (group) data on such values.\n", - "print(\"Number of rows:\", len(surveys_df))\n", - "print(len(surveys_df['weight'].unique())) #includes nan\n", - "print(len(surveys_df.groupby(['weight']).groups)) #does not include nan" - ] - }, - { - "cell_type": "markdown", - "id": "79ae54cf", - "metadata": {}, - "source": [ - "### Exercise 11\n", - "In the given example of vertical concatenation, you concatenated two DataFrames with the same columns. What would happen if the two DataFrames to concatenate have different column number and names?\n", - "\n", - " 1. Create a new DataFrame using the last 10 rows of the species DataFrame (`species_df`);\n", - " 2. Concatenate vertically `surveys_df_sub_first10` and your just created DataFrame;\n", - " 3. Print the concatenated DataFrame info on the screen. How may rows does it have? What happened to the columns? Explain why you get this result." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "18b13126", - "metadata": {}, - "outputs": [], - "source": [ - "species_df = pd.read_csv(\"../data/species.csv\")\n", - "species_df_sub_last10 = species_df.tail(10)\n", - "\n", - "surveys_df_sub_first10 = surveys_df.head(10)\n", - "vert_concat = pd.concat([surveys_df_sub_first10, species_df_sub_last10], axis=0)\n", - "\n", - "vert_concat" - ] - }, - { - "cell_type": "markdown", - "id": "aa6d4ee8", - "metadata": {}, - "source": [ - "We get a total of 20 rows and 12 columns. The original dataframes together had a total of 13 columns. As they both have a column `species_id`, this one is collapsed. All other columns are padded with `NaN` values.\n", - "We expect 20 rows, as we are putting two DataFrames of 10 rows one after the other. The padding of the columns happens because these two DataFrames do not have the same column names. To keep all the information that was in the original DataFrames, the padding of columns that occur in only one of the two is necessary." - ] - }, - { - "cell_type": "markdown", - "id": "9478026d", - "metadata": {}, - "source": [ - "### Exercise 12\n", - "In the given example of horizontal concatenation, you first concatenated two DataFrame with different indices, then reset the indices of the second one. Based on the outcome of these two cases, try to answer the following questions:\n", - " 1. What happens when you concatenate horizontally two DataFrames with different indexing?\n", - " 2. What happens when you concatenate horizontally two DataFrames with the same columns?\n", - " 3. What happens when you try to select a column of the `horizontal_stack` DataFrame we just created?\n", - " 4. How can you select a specific column, when multiple columns share a name?" - ] - }, - { - "cell_type": "markdown", - "id": "b5b01c88", - "metadata": {}, - "source": [ - "1. The columns of both DataFrames are kept, duplicates are not merged, and the rows of both DataFrames are kept as well, no merging there either. This results in the two original DataFrames appearing in a checker-pattern in the resulting DataFrames, with the empty spaces padded out with `NaN` values.\n", - "2. Columns still are not merged, but now, rows with a common index are merged. This means that the information of both rows is put into a single row in the resulting DataFrame. If no corresponding row exists in the other DataFrame, the row is still padded with `NaN`'s in the result. But if a corresponding row (with the same index) *does* exists, this is no longer necessary." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0faee1fd", - "metadata": {}, - "outputs": [], - "source": [ - "# 3.\n", - "surveys_df_sub_last10 = surveys_df.tail(10)\n", - "surveys_df_sub_last10 = surveys_df_sub_last10.reset_index(drop=True)\n", - "horizontal_stack = pd.concat([surveys_df_sub_first10, surveys_df_sub_last10], axis=1)\n", - "horizontal_stack['species_id']" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4f860304", - "metadata": {}, - "outputs": [], - "source": [ - "# 4.\n", - "horizontal_stack.iloc[:,5]" - ] - }, - { - "cell_type": "markdown", - "id": "d6382b5f-9c13-4ceb-88f6-f7ba13f797f7", - "metadata": { - "tags": [] - }, - "source": [ - "### Exercise 13\n", - "Time to play with plots! Look at the pandas.DataFrame.plot() documentation [here](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.html) and change your data visualization selecting different DataFrame columns, x and y axes, and kind of plot (try at least three different plots).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1896c89b-f2c2-41ae-9a18-9b9fb8a87648", - "metadata": {}, - "outputs": [], - "source": [ - "fig, ax1 = plt.subplots() # prepare a matplotlib figure\n", - "\n", - "surveys.plot(\"hindfoot_length\", \"weight\", kind=\"scatter\", ax=ax1)\n", - "\n", - "# Provide further adaptations with matplotlib:\n", - "ax1.set_xlabel(\"Hindfoot length\")\n", - "ax1.tick_params(labelsize=16, pad=8)\n", - "fig.suptitle('Scatter plot of weight versus hindfoot length', fontsize=15)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.8" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}