diff --git a/README.md b/README.md index f8d0424..e49afab 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,8 @@ # JupyterLite Demo -[![lite-badge](https://jupyterlite.rtfd.io/en/latest/_static/badge.svg)](https://jupyterlite.github.io/demo) +[![lite-badge](https://jupyterlite.rtfd.io/en/latest/_static/badge.svg)](https://humbledata.org/online-workshop/lab/index.html) + +> This repository holds the contents for the HumbelData workshop using JupyterLite. JupyterLite deployed as a static site to GitHub Pages, for demo purposes. diff --git a/content/notebooks/1. Beginning with Python.ipynb b/content/notebooks/1. Beginning with Python.ipynb index f393375..5d56c1e 100644 --- a/content/notebooks/1. Beginning with Python.ipynb +++ b/content/notebooks/1. Beginning with Python.ipynb @@ -1,8 +1,28 @@ { + "metadata": { + "kernelspec": { + "name": "python3", + "language": "python", + "display_name": "Python 3 (ipykernel)" + }, + "language_info": { + "codemirror_mode": { + "name": "python", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8" + } + }, + "nbformat_minor": 4, + "nbformat": 4, "cells": [ { "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", "

\n", @@ -11,11 +31,11 @@ "Introduction to Python\n", "\n", "
" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Welcome to learning Python!\n", "\n", @@ -24,108 +44,139 @@ "We will walk you through different aspects of the Python language interactively. Take your time to experiment with it if you like and don't hesitate to ask or Google things. One of the first lessons in programming is using the documentation and information shared by other programmers. Jupyter has another trick, where you can put your cursor into the brackets of a function call such as `print()` and hit **Shift + Tab**. This will let you see the documentation of a function directly in the notebook (*pro-tip*: you can hit it up to four times for different effects).\n", "\n", "As for Python itself, one of the big strengths of Python is the extensibility. It has a surprising amount of functionality directly within the core language, however, you can `import` almost arbitrary code others make available as libraries. Below you can see a special import that shows you the \"Zen of Python\" a set of guidelines that could guide your programming journey.\"" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# We can use comments to document our code in a coding cell.\n", + "import this # Zen of Python" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# We can use comments to document our code in a coding cell.\n", - "import this # Zen of Python" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**--> Simple is better than complex.** \n", "It is really easy to print ***Hello World*** in Python:" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "print('Hello World!')" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "print('Hello World!')" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**PEP 8** is Python's style guide. You can find it here:\n", "https://www.python.org/dev/peps/pep-0008/\n", "\n", "It is good to know about, but when you become a professional programmer there are programs called a \"linter\" that will help you adhere to PEP 8." - ] + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Before you get started, we just need to do a small amount of set up. We're going to load a module called NumPy which we'll need to complete this notebook. Don't stress if you don't understand this code - it's specific to the JupyterLite notebooks we're using for this course." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "import pyodide_js\n", + "\n", + "# Install NumPy\n", + "await pyodide_js.loadPackage('numpy')" + ], + "metadata": { + "collapsed": false + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "

\n", "Variables\n", "


\n", "
" - ] + ], + "metadata": { + "collapsed": false + } }, { "cell_type": "markdown", - "metadata": {}, "source": [ "In programming it's very useful to store values. Accessing values through names is called a variable. Python is very user-friendly in that it will let you store most things in a variable, without making space in the computer's space explicitly. Moreover, computers need to differentiate between the type of data, such as, `5` being an integer and `'Hello'` being a string, but Python attempts to handle these intuitively for you. You will learn about the different types in the following sections!\n", "\n", "**Python is an object oriented programming language. You do not need to declare variables (or their types) before using them as every variable in Python is an object.** " - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "name = 'Sandrine'" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "name = 'Sandrine'" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "print(name)" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "print(name)" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Moreover, variables can easily be updated. Try it out below!" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -139,200 +190,219 @@ "\n", "\n", "---" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Assign another string to the variable 'name' and print this variable" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_01.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_01.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**!!! Variable can can change type when re-assigned.**" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Assign a number (without quotes) to the variable 'name' and print this variable" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_02.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_02.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "

\n", "Strings\n", "


\n", "
" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "A string always begins and ends with a single ( ' ) or double ( \\\" ) quotes. There is no difference, except if there is an apostrophe ( ' ) inside the string." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "'Beginners Data Workshop'" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "'Beginners Data Workshop'" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "\"Beginner's Data Workshop\"" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "\"Beginner's Data Workshop\"" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Write *I'm enjoying this workshop!* using double quotes, and then single quotes." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# double quotes\n" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# double quotes\n" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_03.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_03.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# single quotes\n" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# single quotes\n" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_04.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_04.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**Oh no, an error!** Errors are nothing to be afraid of. Think of them as friendly messages trying to help you understand what's gone wrong. Here's how to read this:\n", "- Read errors backwards, so start at the bottom! It's a \"SyntaxError\" which means there's something wrong with our Python code.\n", @@ -342,294 +412,321 @@ "**It turns out, if you want to use single quotes inside single quotes, you need to \"escape\" the quote with a backslash ( \\\\ ).**\n", "\n", ">Let's try that!" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# single quotes, second try\n" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# single quotes, second try\n" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_05.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_05.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "As mentioned before, Python tries to handle everything as intuitively as possible. That means strings can be added together." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "'We are ' + 'everywhere around the world.'" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "'We are ' + 'everywhere around the world.'" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Also, strings can even be multiplied by a number." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "'Great! 🎉' * 3" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "'Great! 🎉' * 3" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "'😂' * 50" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "'😂' * 50" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can access parts of strings by slicing the string. A character of a string (which is considered as a string of length 1 by Python) using slice, and a substring using slice range. Something important to note:\n", "\n", "**!!! Like birthdays, Python starts counting from 0! (It is \"zero-indexed\")** \n", "\n", "(If you're interested why, here's a historical [letter from Dijkstra](https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html) about it.)" - ] + ], + "metadata": {} }, { + "cell_type": "markdown", + "source": [ + "![image.png](attachment:image.png)" + ], + "metadata": {}, "attachments": { "image.png": { "image/png": "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" } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)" - ] + } }, { "cell_type": "code", - "execution_count": null, + "source": [ + "s = 'I am a Pythonista.'" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "s = 'I am a Pythonista.'" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "***Slice*** \n", "We can access characters of a string by referencing the position (\"index\") numbers within square brackets." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# Selecting the first character of the string s\n", + "s[0]" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# Selecting the first character of the string s\n", - "s[0]" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "> Select the last character of the string s" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_06.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_06.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "***Slice range*** \n", "We can get a range of characters of a string by using a slicing range." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# Select from position 2 up to but not including position 6 of the string s\n", + "s[2:6] # 6 is excluded" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# Select from position 2 up to but not including position 6 of the string s\n", - "s[2:6] # 6 is excluded" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can skip the start (resp. stop) number `s[:6]`. Then it start form index 0 (resp. end at the highest index)." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Select the last 3 characters of the string s" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_07.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_07.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can check if a string contains another string inside of it (a \"substring\"), using *in* and *not in*.\n", "\n", "**!!! Python is case-sensitive! The string `'a'` is not equal to `'A'`***" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], "source": [ "# Checking if s contains 'python'\n", "print(s)\n", "'python' in s" - ] + ], + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "> Check if s does not contain 'I' (capital i)" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_08.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_08.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -637,409 +734,442 @@ "Numbers\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Python has different numerical types. Two of which are used more often than others:\n", "- **Integers:** These are whole numbers, i.e. `1`, `2`, `-5`\n", "- **Floats:** \"Floating point\" numbers are those with a decimal point, i.e. `3.14158`, `2.5`, `0.1` and even `3.0`. \n", "\n", "Python attempts to deal with these numbers intuitively when integers and floats are mixed." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Basic Operators" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**Addition:** \n", - ">Try adding two numbers." - ] + ">Try adding 3 and 4 together." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_09.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_09.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**Subtraction:**\n", - "> Try subtracting two numbers." - ] + "> Try subtracting 6 from 10.0." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_10.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_10.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**Multiplication:** \n", "The sign for multiplication is *. \n", - ">Try multiplying two numbers." - ] + ">Try multiplying 15 and 12." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_11.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_11.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**Exponent:** \n", "The sign for exponent (or power) is *`**`*.\n", "\n", - "> Try the power of an integer." - ] + "> Try raising 2 to the power of 6." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_12.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_12.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Try the power of a float" - ] + ">Try raising a float to a power this time. Calculate the square of 3.1." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_13.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_13.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Try the power of an integer written as a float (e.g. 12.0)" - ] + ">Now try something similar - raise an integer written as a float to a power. Calculate the square of 5, where 5 is written as a float." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_14.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_14.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**Division and modulo**\n", "- The sign for division is **`/`**.\n", "- The sign for floor division is **`//`**. It returns the \"quotient\" of a division - how many times one number goes into another. (\"If six people can sit around a dinner table, and we have 99 guests coming, how many tables do we need?\")\n", "- The **`%`** sign is the [modulo](https://en.wikipedia.org/wiki/Modulo_operation), which returns the \"remainder\" after division." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Divide 6 by 2" - ] + ">Divide 6 by 2." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_15.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_15.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Try the floor division of 6 by 2" - ] + ">Try the floor division of 6 by 2." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_16.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_16.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Divide 19 by 5" - ] + ">Divide 19 by 5." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_17.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_17.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "*Note*: division returns a float." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**The floor division returns an int, the non-fractional part.** \n", - ">Try the floor division of 19 by 5" - ] + ">Try the floor division of 19 by 5." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_18.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_18.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**Modulo returns the remainder of the division**" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Calculate 19 modulo 5" - ] + ">Calculate 19 modulo 5." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_19.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_19.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**--> 19 = 3 * 5 + 4**" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -1047,44 +1177,48 @@ "Order of operations\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "The order of operations in Python respects the usual rules of mathematics (brackets -> powers -> division/multiplication -> add/subtract). **If in doubt, use brackets** to make it clear (to yourself, and anyone who might be reading your code) what you're trying to do." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "5 + 6 * 10" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "5 + 6 * 10" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "(5 + 6) * 10" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "(5 + 6) * 10" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -1092,110 +1226,119 @@ "Booleans\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Booleans are the two constant values `True` and `False`. Python implements the concept of \"truthiness\", that means their numerical values are 1 and 0. These values are especially important for comparisons, therefore, we'll also learn about a new operator:\n", "\n", "**`==`** is an equality operator, different from **`=`** which is the assignment operator you used to assign variables." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "True == 1 # '==' is an equality operator, different from '=' which is an assignment operator" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "True == 1 # '==' is an equality operator, different from '=' which is an assignment operator" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "False * 3" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "False * 3" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Using **`!=`** , check if False is not equal to 2.\"" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_20.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_20.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Check if the length of your name is greater than 8." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "len()" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_21.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_21.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can use `and` and `or` operators with booleans in Python. Type them below and see how the color of the text changes, because Python recognises the keyword! These can be used to chain together multiple comparisons. These follow mathematical logic.\n", "\n", @@ -1207,35 +1350,38 @@ "| False | False | False | False |\n", "\n", "> Check if the length of your name is greater than 5 and the length of your mentor's name is less than 7." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_22.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_22.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -1243,397 +1389,433 @@ "Lists\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "A list is a list of comma-separated values between square brackets.\n", "\n", "The items of a list can have different types." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "list_greeting = ['Hallo', 'Bonjour', 10, 'Hello', 'Ciao', False]" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "list_greeting = ['Hallo', 'Bonjour', 10, 'Hello', 'Ciao', False]" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can access a single value using a slice, and several values using slice range. Check the \"string slicing\" section above for this." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Get the first item of the list." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_23.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_23.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Get every the items from the list, starting with the 4th one.\n", "\n", "Note that there is no need to put a number after the colon when when want to select until the end of the list." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Get the items starting with the one with index 3 until the end of the list." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_24.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_24.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**Get the items from the list until the 4th one.**" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Get the items from the beginning of the list until the value with index 4 (index 4 is excluded)." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_25.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_25.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**Advanced slicing allows us to set how the list's index will increment between the start/stop indexes we select.** \n", "The slicing then looks like this: [start:stop:step] \n", "For example, if we want to select every third items of a list, we will set the step as 3." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Get every other items from the list of greetings" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_26.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_26.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**We can update a list by re-assigning a value selected using a slice.** \n", "For example, we can replace False with 'Ave' in list_greeting." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "list_greeting[-1] = 'Ave'\n", + "print(list_greeting)" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "list_greeting[-1] = 'Ave'\n", - "print(list_greeting)" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Replace 10 with Hola in list_greetings, then print list_greeting to check it." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_27.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_27.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can have lists inside a list, these are often called \"nested lists\":" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "list_of_lists = [[1, 2, 3], [4, 5]]" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "list_of_lists = [[1, 2, 3], [4, 5]]" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "list_of_lists[0] # access the first element of the list, which is a list." + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "list_of_lists[0] # access the first element of the list, which is a list." - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "list_of_lists[0][-1] # access the last element of the first list." + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "list_of_lists[0][-1] # access the last element of the first list." - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can concatenate lists using ' + '." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "[1, 2, 3] + [4, 5, 6]" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "[1, 2, 3] + [4, 5, 6]" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can also use the multiplication to repeat values in a list (only works with integers)." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "['Hey'] * 5" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "['Hey'] * 5" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can also use `in` / `not in` with lists." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Check if `10` is in `list_greeting`." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_28.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_28.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Check if 'Ole' is not in list_greeting." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_29.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_29.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -1641,216 +1823,236 @@ "Built-in functions\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "You've seen your first function at the very beginning of this notebook, i.e. `print(\"Hello World\")`. Functions are a way for you to write reusable code. In the case before `print()` is Python's way for you to show an output you provide. However, there are many other useful functions that Python comes with, that are provided by other libraries, or written by you yourself to save you from repeating some code.\n", "\n", "The functions that are always available in Python can be found here:\n", "https://docs.python.org/3/library/functions.html" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Print *'Here we are!'*." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_30.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_30.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Compute the length of the string variable `snakes`." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], "source": [ "snakes = \"🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍\"" - ] + ], + "metadata": { + "trusted": true + }, + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_31.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_31.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Compute the length of list_greeting." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_32.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_32.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Work out the maximum of 1, 2, 3, 4 and 5." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_33.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_33.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Round the number 123.45 to the nearest integer." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_34.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_34.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Round the number 123.45 to 1 decimal place." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_35.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_35.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -1858,64 +2060,69 @@ "Methods\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "A method is a function associated to an object. Basically, it provides a way for an object to know functions about themselves.\n", "\n", "For example, we can change the string `s` to upper case using the `.upper()` method." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "s.upper()" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "s.upper()" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Using the append method, add 'Aloha' to list_greeting." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_36.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_36.py" - ] + "execution_count": 3, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -1923,20 +2130,20 @@ "Importing modules\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can import modules (Python code that can define functions, classes and variables).\n", "\n", "Usually, we write all the imports at the beginning of a Python program or notebook." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**A small warning** \n", "Ensure you trust the packages you're installing!\n", @@ -1946,77 +2153,84 @@ "2. Do I trust giving their code access to my computer?\n", "3. `pip install` especially can be a little more dangerous, anyone can upload something to the Python Package Index (\"PyPI\" for short), which is where `pip` installs from. So be very careful especially as the smallest typo can be a security risk!\n", "4. `conda install` is more of a walled garden and as such better positioned for enterprise usage." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "> From the **math** library, import **sqrt** to work out the square root of **24 336**." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_37.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_37.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Python programmers really are lazy! (Or obsessive about productivity, take your pick!)\n", "\n", "Hence, you can define aliases for imports. The `as np` is two characters long, whereas `numpy` is five. It's less to type, when you write long programs.\n", "\n", "> Import `numpy as np` and try **`np.sin(np.pi/4)`**." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/01_38.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/01_38.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -2024,28 +2238,8 @@ "Take a well deserved break, brew a relaxing beverage of your choice or go have a snack, maybe share a picture of your snack/drink in the #random channel, we love to see pictures from everyone attending around the world. ☕️\n", "\n", "![](https://media0.giphy.com/media/3otPoS81loriI9sO8o/200.gif)" - ] + ], + "metadata": {} } - ], - "metadata": { - "kernelspec": { - "display_name": "Python (beginners-data-workshop)", - "language": "python", - "name": "beginners-data-workshop" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.13" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + ] } diff --git a/content/notebooks/2. First steps with Pandas.ipynb b/content/notebooks/2. First steps with Pandas.ipynb index 85395c0..eb52b7c 100644 --- a/content/notebooks/2. First steps with Pandas.ipynb +++ b/content/notebooks/2. First steps with Pandas.ipynb @@ -1,8 +1,28 @@ { + "metadata": { + "kernelspec": { + "name": "python", + "display_name": "Python (Pyodide)", + "language": "python" + }, + "language_info": { + "codemirror_mode": { + "name": "python", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8" + } + }, + "nbformat_minor": 4, + "nbformat": 4, "cells": [ { "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", "

\n", @@ -11,32 +31,32 @@ "Data Analysis with Pandas\n", "\n", "
" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "> ***Note***: This notebook contains solution cells with ***a*** solution. Remember there is not only one solution to a problem! \n", "> \n", "> You will recognise these cells as they start with **# %**. \n", "> \n", "> If you would like to see the solution, you will have to remove the **#** (which can be done by using **Ctrl** and **?**) and run the cell. If you want to run the solution code, you will have to run the cell again." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "

\n", "Data analysis packages\n", "


\n", "
" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Data Scientists use a wide variety of libraries in Python that make working with data significantly easier. Those libraries primarily consist of:\n", "\n", @@ -55,12 +75,31 @@ "\n", "Though there are countless others available.\n", "\n", - "For today, we'll primarily focus ourselves around the library that is 99% of our work: `pandas`. Pandas is built on top of the speed and power of NumPy." - ] + "For today, we'll primarily focus ourselves around the library that is 99% of our work: `pandas`. Pandas is built on top of the speed and power of NumPy.\n", + "\n", + "Run the code below to get the imports we need for this notebook." + ], + "metadata": {} + }, + { + "cell_type": "code", + "source": [ + "import pyodide_js\n", + "\n", + "# Install NumPy\n", + "await pyodide_js.loadPackage('numpy')\n", + "\n", + "# Install Pandas\n", + "await pyodide_js.loadPackage('pandas')" + ], + "metadata": { + "trusted": true + }, + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -68,55 +107,48 @@ "Imports\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "import pandas as pd" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "import pandas as pd" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Import numpy using the convention seen at the end of the first notebook." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_01.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "# %load ../solutions/02_01.py" - ] + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -124,121 +156,132 @@ "Loading the data\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "To see a method's documentation, you can use the help function. In Jupyter, you can also just put a question mark before the method." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "?pd.read_csv" + ], "metadata": { "jupyter": { "outputs_hidden": false }, - "scrolled": true + "scrolled": true, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "?pd.read_csv" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "To load the dataframe we are using in this notebook, we will provide the path to the file: ../data/Penguins/penguins.csv" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Load the dataframe, read it into a pandas DataFrame and assign it to df" - ] + ">Load the dataframe, read it into a pandas DataFrame and assign it to df." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_02.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_02.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**To have a look at the first 5 rows of df, we can use the *head* method.**" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df.head()" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df.head()" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Have a look at the last 3 rows of df using the tail method" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_03.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_03.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -246,112 +289,121 @@ "General information about the dataset\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**To get the size of the datasets, we can use the *shape* attribute.** \n", "The first number is the number of row, the second one the number of columns" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Show the shape of df (do not put brackets at the end)" - ] + ">Show the shape of df (do not put brackets at the end)." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_04.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_04.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Get the names of the columns and info about them (number of non null and type) using the info method." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_05.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_05.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Get the columns of the dataframe using the columns attribute." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_06.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_06.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -359,62 +411,55 @@ "Display settings\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can check the display option of the notebook." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "pd.set_option('display.max_rows', [number of rows])" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "pd.options.display.max_rows" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Force pandas to display 25 rows by changing the value of the above." - ] + ">Force pandas to display 25 rows by changing the value of [number of rows] above." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_07.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "# %load ../solutions/02_07.py" - ] + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -422,270 +467,302 @@ "Subsetting data\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can subset a dataframe by label, by index or a combination of both. \n", "There are different ways to do it, using .loc, .iloc and also []. \n", "See [documentation ](https://pandas.pydata.org/pandas-docs/stable/indexing.html)." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Display the 'bill_length_mm' column" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_08.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_08.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "*Note:* We could also use `df.bill_length_mm`, but it's not the greatest idea because it could be mixed with methods and does not work for columns with spaces." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Have a look at the 12th observation:" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# using .iloc (uses positions, \"i\" stands for integer)\n" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# using .iloc (uses positions, \"i\" stands for integer)\n" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_09.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_09.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# using .loc (uses indexes and labels)\n" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# using .loc (uses indexes and labels)\n" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_10.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_10.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Display the **bill_length_mm** of the last three observations." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# using .iloc\n" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# using .iloc\n" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_11.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_11.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# using .loc\n" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# using .loc\n" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_12.py" + ], "metadata": { "jupyter": { "outputs_hidden": false }, - "scrolled": true + "scrolled": true, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_12.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "And finally look at the **flipper_length_mm** and **body_mass_g** of the 146th, the 8th and the 1rst observations:" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# using .iloc\n" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# using .iloc\n" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_13.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_13.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# using .loc\n" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# using .loc\n" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_14.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_14.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**!!WARNING!!** Unlike Python and ``.iloc``, the end value in a range specified by ``.loc`` **includes** the last index specified. " - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df.iloc[5:10]" + ], "metadata": { "jupyter": { "outputs_hidden": false }, - "scrolled": true + "scrolled": true, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df.iloc[5:10]" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df.loc[5:10]" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df.loc[5:10]" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -693,85 +770,92 @@ "Filtering data on conditions\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**We can also use condition(s) to filter.** \n", "We want to display the rows of df where **body_mass_g** is greater than 4000. We will start by creating a mask with this condition." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "mask_PW = df['body_mass_g'] > 4000\n", + "mask_PW" + ], "metadata": { "jupyter": { "outputs_hidden": false }, - "scrolled": true + "scrolled": true, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "mask_PW = df['body_mass_g'] > 4000\n", - "mask_PW" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Note that this return booleans. If we pass this mask to our dataframe, it will display only the rows where the mask is True." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df[mask_PW]" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df[mask_PW]" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Display the rows of df where **body_mass_g** is greater than 4000 and **flipper_length_mm** is less than 185." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_15.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_15.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -779,65 +863,70 @@ "Values\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can get the number of unique values from a certain column by using the `nunique` method.\n", "\n", "For example, we can get the number of unique values from the species column:" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df['species'].nunique()" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df['species'].nunique()" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can also get the list of unique values from a certain column by using the `unique` method.\n", ">Return the list of unique values from the species column" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_16.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_16.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -845,341 +934,373 @@ "Null Values and NaN\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "When you work with data, you will quickly learn that data is never \"clean\". These values are usually referred to as null value. In computation it is best practice to define a \"special number\" that is \"**N**ot **a** **N**umber\" also called NaN.\n", "\n", "We can use the `isnull` method to know if a value is null or not. It returns boolean values." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df['flipper_length_mm'].isnull()" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df['flipper_length_mm'].isnull()" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "**We can apply different methods one after the other.**. \n", "For example, we could apply to method `sum` after the method `isnull` to know the number of null observations in the **flipper_length_mm** column.\n", ">Get the total number of null values for **flipper_length_mm**." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": {}, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], "source": [ - "# %load ../solutions/02_17.py" - ] + "# %run ../solutions/02_17.py" + ], + "metadata": { + "trusted": true + }, + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "To get the count of the different values of a column, we can use the `value_counts` method.\n", "\n", "For example, for the species column:" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df['species'].value_counts()" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df['species'].value_counts()" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "If we want to know the count of NaN values, we have to pass the value `False` to the parameter **dropna** (set to `True` by default).\n", "> Return the proportion for each sex, including the NaN values.\"" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_18.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_18.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "To get the proportion instead of the count of these values, we have to pass the value `True` to the parameter **normalize**.\n", ">Return the proportion for each species." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_19.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_19.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Using the index attribute, get the indexes of the observation without **flipper_length_mm**" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_20.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_20.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Use the **[dropna](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.dropna.html)** method to remove the row which only has NaN values.\n", ">Get the help for the dropna method." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_21.py" + ], "metadata": { "jupyter": { "outputs_hidden": false }, - "scrolled": true + "scrolled": true, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_21.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Use the dropna method to remove the row of `df` where all of the values are NaN, and assign it to `df_2`." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_22.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_22.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can use a f-string to format a string. We have to write a `f` before the quotation mark, and write what you want to format between curly brackets." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "print(f'shape of df: {df.shape}')" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "print(f'shape of df: {df.shape}')" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "> Print the number of rows of `df_2` using a f_string. Did we lose any rows between `df` and `df_2`? If not, why not?" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_23.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_23.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Use the dropna method to remove the rows of `df_2` which contains any NaN values, and assign it to `df_3`" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_24.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_24.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Print the number of rows of `df_3` using a f_string." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_25.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_25.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -1187,64 +1308,69 @@ "Duplicates\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Remove the duplicates rows from `df_3`, and assign the new dataframe to `df_4`" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_26.py" + ], "metadata": { "jupyter": { "outputs_hidden": false }, - "scrolled": true + "scrolled": true, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_26.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# checking the shape of df_4\n", + "df_4.shape" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# checking the shape of df_4\n", - "df_4.shape" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "You should see that 4 rows have been dropped. " - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -1252,185 +1378,208 @@ "Some stats\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Use the describe method to see how the data is distributed (numerical features only!)" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_27.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_27.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can also change the **species** column to save memory space. Note: You may receive a **SettingWithCopyWarning** - you can safely ignore this error for this notebook." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df_4['species'] = df_4['species'].astype('category')" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df_4['species'] = df_4['species'].astype('category')" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Using the dtypes attribute, check the types of the columns of `df_4`" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_28.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_28.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can also use the functions count(), mean(), sum(), median(), std(), min() and max() separately if we are only interested in one of those." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Get the minimum for each numerical column of `df_4`" - ] + ">Get the minimum for each numerical column of `df_4`. Make sure to include the argument `numeric_only=True` in the function to filter results to only numeric columns." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_29.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_29.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ - ">Calculate the maximum of the **flipper_length_mm**" - ] + ">Calculate the maximum of the **flipper_length_mm**." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_30.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_30.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "We can also get information for each species using the `groupby` method.\n", "\n", "\n", - "> Get the median for each **species**." - ] + "> Get the median for each **species**. Again, make sure to include the argument `numeric_only=True` in the function to filter results to only numeric columns." + ], + "metadata": {} }, { "cell_type": "code", + "source": [], + "metadata": {}, "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# %run ../solutions/02_31.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "# %load ../solutions/02_31.py" - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -1438,59 +1587,42 @@ "Saving the dataframe as a csv file\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ ">Save df_4 using this path: `'../data/Penguins/my_penguins.csv'`" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "# %run ../solutions/02_32.py" + ], "metadata": { "jupyter": { "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "# %load ../solutions/02_32.py" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (system-wide)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 + }, + "collapsed": false, + "trusted": true }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" + "execution_count": null, + "outputs": [] } - }, - "nbformat": 4, - "nbformat_minor": 4 + ] } diff --git a/content/notebooks/3.1 Visualization with Matplotlib.ipynb b/content/notebooks/3.1 Visualization with Matplotlib.ipynb index 5385877..567fb7f 100644 --- a/content/notebooks/3.1 Visualization with Matplotlib.ipynb +++ b/content/notebooks/3.1 Visualization with Matplotlib.ipynb @@ -1,8 +1,28 @@ { + "metadata": { + "kernelspec": { + "name": "python", + "display_name": "Python (Pyodide)", + "language": "python" + }, + "language_info": { + "codemirror_mode": { + "name": "python", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8" + } + }, + "nbformat_minor": 4, + "nbformat": 4, "cells": [ { "cell_type": "markdown", - "metadata": {}, "source": [ "
\n", "

\n", @@ -11,103 +31,119 @@ "Data visualization with matplotlib\n", "\n", "
" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "![](https://matplotlib.org/_static/logo2_compressed.svg)" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "

\n", "Import pyplot in matplotlib (and pandas)\n", "


\n", "
" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "According to the [official documentation](https://matplotlib.org/gallery/index.html):\n", "\n", "`matplotlib.pyplot` is a collection of command style functions that make Matplotlib work like MATLAB. Each pyplot function makes some change to a figure: e.g., creates a figure, creates a plotting area in a figure, plots some lines in a plotting area, decorates the plot with labels, etc.\n", "\n", "`pyplot` is mainly intended for interactive plots and simple cases of programmatic plot generation." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "![](https://miro.medium.com/max/2000/1*swPzVFGpYdijWAmbrydCDw.png)" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], "source": [ "%matplotlib inline\n", "# this is for ipython interpreter to show the plot in Jupyter\n", "\n", "import pandas as pd\n", "import matplotlib.pyplot as plt" - ] + ], + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": 1, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Import the dataframe again, read it into a pandas DataFrame and assign it to df." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df = pd.read_csv('../data/Penguins/penguins_clean.csv')" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df = pd.read_csv('../data/Penguins/penguins_clean.csv')" - ] + "execution_count": 2, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Refresh our memory about how the data looks like" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df.head()" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df.head()" + "execution_count": 3, + "outputs": [ + { + "execution_count": 3, + "output_type": "execute_result", + "data": { + "text/plain": " species island bill_length_mm bill_depth_mm flipper_length_mm \\\n0 Adelie Torgersen 39.1 18.7 181.0 \n1 Adelie Torgersen 39.5 17.4 186.0 \n2 Adelie Torgersen 40.3 18.0 195.0 \n3 Adelie Torgersen NaN NaN NaN \n4 Adelie Torgersen 36.7 19.3 193.0 \n\n body_mass_g sex \n0 3750.0 Male \n1 3800.0 Female \n2 3250.0 Female \n3 NaN NaN \n4 3450.0 Female ", + "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
speciesislandbill_length_mmbill_depth_mmflipper_length_mmbody_mass_gsex
0AdelieTorgersen39.118.7181.03750.0Male
1AdelieTorgersen39.517.4186.03800.0Female
2AdelieTorgersen40.318.0195.03250.0Female
3AdelieTorgersenNaNNaNNaNNaNNaN
4AdelieTorgersen36.719.3193.03450.0Female
\n
" + }, + "metadata": {} + } ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Using DataFrame.plot() in pandas\n", "\n", @@ -117,89 +153,165 @@ "\n", "You will find this page very helpful:\n", "https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.plot.html" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "#### Example: Box plot in general" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df.plot(kind='box')" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df.plot(kind='box')" + "execution_count": 4, + "outputs": [ + { + "execution_count": 4, + "output_type": "execute_result", + "data": { + "text/plain": "" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {} + } ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "The scales of our data don't align particularly well. So for the sake of plotting, we'll ignore the body mass of the penguins." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], "source": [ "df.drop([\"body_mass_g\"], axis=1).plot(kind='box')" + ], + "metadata": { + "trusted": true + }, + "execution_count": 5, + "outputs": [ + { + "execution_count": 5, + "output_type": "execute_result", + "data": { + "text/plain": "" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {} + } ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "#### Better presentation: figure size, add title and legend" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df.drop([\"body_mass_g\"], axis=1).plot(kind='box', figsize=(10,8), title='Box plot of different measurements of species of penguin', legend=True)" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df.drop([\"body_mass_g\"], axis=1).plot(kind='box', figsize=(10,8), title='Box plot of different measurements of species of penguin', legend=True)" + "execution_count": 6, + "outputs": [ + { + "execution_count": 6, + "output_type": "execute_result", + "data": { + "text/plain": "" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAz8AAAKqCAYAAAAUieAHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPlUlEQVR4nO3deVxVdf7H8fdlRzZBWcQFEFRwxSyXstQ00UlHyxZryiXLFrXIZmyZTK0myxYtM81m0rQs00Yrp7Iyl2zUadNWFf2hlgtYKQiJCnx/fzSc8Qoi2NWLfl/Px+M+6p77Pd/zuQfO1/vmnPO9LmOMEQAAAACc5Xy8XQAAAAAAnA6EHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQf4CzRtWtXde3a1dtluMnJydEVV1yhOnXqyOVyacqUKdVaf9u2bXK5XJo9e7azbPz48XK5XG7tiouLNWbMGDVs2FA+Pj7q37+/JKmgoEA33nij4uLi5HK5lJmZ+fveEHAGmzt3rlJTU+Xv76/atWt7u5yTkpiYqCFDhni7jAodbxyyQUXjMlBT+Xm7AKAmmT17toYOHeq2LDo6Wi1atNCYMWPUu3dvL1V26vz666+aNGnSKQlPd955p5YuXapx48YpLi5O5557rkf7L/Piiy/q8ccfV2Zmps455xw1atRIkvTII49o9uzZGjt2rJKTk5WWlnZKtu8J8+bNU25uLgHtLPbdd9/p9ddf15AhQ5SYmHhat71x40YNGTJEvXr10j333KNatWqd1u3b4HjjEICaxWWMMd4uAqgpysLPgw8+qKSkJBljlJOTo9mzZ+vbb7/V22+/rT59+ni7zAqVBZcVK1ZUa72ffvpJ0dHRGjdunMaPH+/RmuLi4tSjRw+9/PLLJ7X+tm3blJSUpFmzZjl/7S0uLlZxcbGCgoKcdgMHDtTq1av1448/uq3fsWNH+fn5afXq1Sf9Hk6XPn366JtvvtG2bdu8XQpOkYULF+rKK6/U8uXLT/tZ2hkzZujWW29VVlaWUlJSTuu2PenQoUPy8fGRv7+/t0sp53jjkA0qGpeBmoozP0AFevfu7XaWYtiwYYqNjdWrr75aY8NPTZSbm+vxy2v8/Pzk5+c+dB1vO7m5uWrevLnHtl1aWqrDhw/zD7wXFBcXq7S0VAEBAd4u5YyUm5srSWfs5W5lAgMDvV3CcZ2K8e5MUdG4DNRU3PMDVEHt2rUVHBxcbnAvLCzUXXfdpYYNGyowMFDNmjXTE088obITqgcPHlRqaqpSU1N18OBBZ71ffvlF9erV0/nnn6+SkpLjbnf27NlyuVxatWqVbr75ZtWpU0fh4eEaNGiQ9u3bd8K6c3NzneAWFBSkNm3a6KWXXnJe37Ztm6KjoyVJEyZMkMvlksvlOuEZoP/7v//TlVdeqaioKNWqVUsdO3bUv/71r3J1G2M0bdo0p9/K7N+/X0OGDFFERIRq166twYMHa//+/eXaHX1tedk9QcuXL9e3337rbGfFihVyuVzKzs7Wv/71L2d52VmVQ4cOady4cUpJSVFgYKAaNmyoMWPG6NChQ27bcrlcGjlypF555RW1aNFCgYGBeu+99yRJO3fu1A033KDY2FgFBgaqRYsWevHFF93WL6vj9ddf19/+9jc1aNBAQUFB6t69u7Zs2eK069q1q/71r39p+/btTq0nuiyqrLYFCxaoefPmCg4OVqdOnfT1119Lkp5//nmlpKQoKChIXbt2rfCM0rp169SrVy9FRESoVq1a6tKliz755BO3Ntu3b9dtt92mZs2aKTg4WHXq1NGVV15Zrr8jR45owoQJatKkiYKCglSnTh117txZH3zwgdv7rOiMx7GXgZX9XJ944glNmTJFycnJCgwM1HfffSfpt0u4rrjiCkVFRSkoKEjnnnuu3nrrLbc+y34HV69erdtvv13R0dGqXbu2br75Zh0+fFj79+/XoEGDFBkZqcjISI0ZM0bHXghRWlqqKVOmqEWLFgoKClJsbKxuvvnmcsdeYmKi+vTpo9WrV6t9+/YKCgpS48aNNWfOHLd6rrzySklSt27d3H5XJemzzz5TRkaG6tatq+DgYCUlJemGG24ot68q8txzzzm/n/Hx8RoxYoTbsZOYmKhx48ZJ+u0y3hMd43v27NHQoUPVoEEDBQYGql69eurXr5/bz7zsPb///vtKT09XUFCQmjdvrn/+85/l+tu/f78yMzOdcTIlJUWPPfaYSktL3dqVlpbq6aefVqtWrRQUFKTo6Gj16tVLn332mdt2j73np6r9v/baa2rXrp3CwsIUHh6uVq1a6emnnz7B3j3xOF/ZOHQ8nt5/Rx8zM2fOdI6Z8847T59++mm5PsvGjaCgILVs2VKLFi0qdxyWjV/Hvo+q3otZNkYtXrxYLVu2dMbJsjEU8BoDwDFr1iwjyXz44Ydm7969Jjc313zzzTfm5ptvNj4+Pub999932paWlpqLL77YuFwuc+ONN5pnn33W9O3b10gymZmZTru1a9caX19fc+eddzrLBg4caIKDg82mTZuqVE+rVq3MhRdeaJ555hkzYsQI4+PjYy666CJTWlrqtO3SpYvp0qWL8/zXX381aWlpxt/f39x5553mmWeeMRdeeKGRZKZMmWKMMaagoMBMnz7dSDKXXXaZmTt3rpk7d67ZsGHDcWvas2ePiY2NNWFhYeavf/2reeqpp0ybNm2Mj4+P+ec//2mMMWbr1q1m7ty5RpK55JJLnH6Pp7S01Fx00UXGx8fH3HbbbWbq1Knm4osvNq1btzaSzKxZs5y248aNM2VDV0FBgZk7d65JTU01DRo0cLazZ88eM3fuXFO3bl2Tnp7uLC8oKDAlJSWmZ8+eplatWiYzM9M8//zzZuTIkcbPz8/069fPrS5JJi0tzURHR5sJEyaYadOmmS+//NLs2bPHNGjQwDRs2NA8+OCDZvr06eaPf/yjkWQmT57srL98+XIjybRt29a0a9fOTJ482YwfP97UqlXLtG/f3mn3/vvvm/T0dFO3bl2n1kWLFh13f5XV1rp1a9OwYUPz6KOPmkcffdRERESYRo0amWeffdY0b97cPPnkk+b+++83AQEBplu3bm7rL1u2zAQEBJhOnTqZJ5980kyePNm0bt3aBAQEmHXr1jntFixYYNq0aWMeeOABM3PmTHPfffeZyMhIk5CQYAoLC5129913n3G5XOamm24yL7zwgnnyySfNNddcYx599FGnzbG/o2UGDx5sEhISnOfZ2dlGkmnevLlp3LixefTRR83kyZPN9u3bzTfffGMiIiJM8+bNzWOPPWaeffZZc9FFFxmXy+X8/hnzv2MnPT3d9OrVy0ybNs1cf/31RpIZM2aM6dy5s7n22mvNc889Z/r06WMkmZdeesmtrhtvvNH4+fmZm266ycyYMcPcfffdJiQkxJx33nnm8OHDTruEhATTrFkzExsba+677z7z7LPPmnPOOce4XC7zzTffGGN+OyZuv/12I8ncd999br+rOTk5JjIy0jRt2tQ8/vjj5oUXXjB//etfTVpaWqW/A8b873jo0aOHmTp1qhk5cqTx9fV1q3HRokXmsssuM5LM9OnTT3iMn3/++SYiIsLcf//95u9//7t55JFHTLdu3czKlSvd3nPTpk1N7dq1zT333GOeeuop06pVq3LjZGFhoWndurWpU6eOue+++8yMGTPMoEGDjMvlMnfccYfbdocMGWIkmd69e5spU6aYJ554wvTr189MnTrVbbuDBw+udv/vv/++kWS6d+9upk2bZqZNm2ZGjhxprrzyykr3b1XG+crGoePx9P4rO2batm1rUlJSzGOPPWYmTZpk6tataxo0aOD2+7pkyRLjcrlM69atzVNPPWXGjh1rIiMjTcuWLd2Ow7Lxa/ny5W61l23reONyGUmmTZs2pl69euahhx4yU6ZMMY0bNza1atUyP/30U6X7HTiVCD/AUco+MB37CAwMNLNnz3Zru3jxYiPJPPzww27Lr7jiCuNyucyWLVucZffee6/x8fExq1atMgsWLHALIFWpp127dm7/eE2aNMlIMm+++aaz7NgPllOmTDGSzMsvv+wsO3z4sOnUqZMJDQ01+fn5xhhj9u7daySZcePGVWkfZWZmGknm448/dpYdOHDAJCUlmcTERFNSUuIsl2RGjBhxwj7L9uWkSZOcZcXFxU5YO9E/sl26dDEtWrQo129CQoK59NJL3ZbNnTvX+Pj4uNVvjDEzZswwkswnn3ziVr+Pj4/59ttv3doOGzbM1KtXr9w/4AMHDjQRERHm119/Ncb878NDWlqaOXTokNPu6aefNpLM119/7Sy79NJL3T54nEjZ72V2draz7PnnnzeSTFxcnPPzNea33z9JTtvS0lLTpEkTk5GR4Ragf/31V5OUlGQuueQSt2XHWrNmjZFk5syZ4yxr06ZNuX19rOqGn/DwcJObm+vWtnv37qZVq1amqKjIWVZaWmrOP/9806RJE2dZ2bFz7Hvs1KmTcblc5pZbbnGWFRcXmwYNGrjV9vHHHxtJ5pVXXnHb/nvvvVdueUJCgpFkVq1a5SzLzc01gYGB5q677nKWlR37x36YXLRokZFkPv3003L7pjK5ubkmICDA9OzZ0+24e/bZZ40k8+KLLzrLyo6bvXv3Vtrnvn37jCTz+OOPV9qu7D2/8cYbzrK8vDxTr14907ZtW2fZQw89ZEJCQszmzZvd1r/nnnuMr6+v2bFjhzHGmI8++shIMrfffnu5bR398zs2/FS1/zvuuMOEh4eb4uLiSt/Xsaozzh9vHKqIp/df2TFTp04d88svvzjt3nzzTSPJvP32286yVq1amQYNGpgDBw44y1asWGEkeTz8BAQEuO2jDRs2GElugRY43bjsDajAtGnT9MEHH+iDDz7Qyy+/rG7duunGG290uyThnXfeka+vr26//Xa3de+66y4ZY/Tuu+86y8aPH68WLVpo8ODBuu2229SlS5dy61Vm+PDhbjf43nrrrfLz89M777xz3HXeeecdxcXF6ZprrnGW+fv76/bbb1dBQYFWrlxZ5e0f22/79u3VuXNnZ1loaKiGDx+ubdu2OZcmVbdPPz8/3Xrrrc4yX19fjRo16qRqrMyCBQuUlpam1NRU/fTTT87j4osvliQtX77crX2XLl3c7hsyxuiNN95Q3759ZYxx6yMjI0N5eXn64osv3PoYOnSo270qF154oaTfLh/8Pbp37+52mUqHDh0kSQMGDFBYWFi55WXbW79+vbKysnTttdfq559/duovLCxU9+7dtWrVKueSmuDgYKefI0eO6Oeff1ZKSopq167t9j5r166tb7/9VllZWb/rPR1twIABzmWZ0m+Xi3700Ue66qqrdODAAafun3/+WRkZGcrKytLOnTvd+hg2bJjb5TgdOnSQMUbDhg1zlvn6+urcc891+3ksWLBAERERuuSSS9x+xu3atVNoaGi535PmzZs7P1fpt8vLmjVrVqWfcdl9IkuWLNGRI0eqtnMkffjhhzp8+LAyMzPl4/O/f85vuukmhYeHu12KWlXBwcEKCAjQihUrTnhpbXx8vC677DLnedkluV9++aX27Nkj6bf9eOGFFyoyMtJtP/bo0UMlJSVatWqVJOmNN96Qy+VyLs87WmWXzFa1/9q1a6uwsNDtMsyqqM44X12e3H9lrr76akVGRjrPjx1rdu3apa+//lqDBg1SaGio065Lly5q1arVSb+X4+nRo4eSk5Od561bt1Z4ePjvHvuA34O704AKtG/f3m3Cg2uuuUZt27bVyJEj1adPHwUEBGj79u2Kj493+5ApyZlOefv27c6ygIAAvfjiizrvvPMUFBSkWbNmVes7EZo0aeL2PDQ0VPXq1at0ZrDt27erSZMmbh+KjldfdWzfvt35MH28flu2bFntPuvVq+f2j7EkNWvW7KRqrExWVpa+//57tw/VRyu7MbxMUlKS2/O9e/dq//79mjlzpmbOnFmlPo6d8rbsw0lV7tuqzLH9RkRESJIaNmxY4fKy7ZUFlMGDBx+377y8PEVGRurgwYOaOHGiZs2apZ07d7rdF5OXl+f8/4MPPqh+/fqpadOmatmypXr16qXrr79erVu3Pun3d+y+37Jli4wxGjt2rMaOHVvhOrm5uapfv77zvDr76OifR1ZWlvLy8hQTE3Pc7RytommNIyMjq/Qz7tKliwYMGKAJEyZo8uTJ6tq1q/r3769rr7220hv8y47hY4+TgIAANW7c+KSO8cDAQD322GO66667FBsbq44dO6pPnz4aNGiQ4uLi3NqmpKSUG8eaNm0q6bf7QuLi4pSVlaWvvvrqhMfb1q1bFR8fr6ioqGrVW9X+b7vtNr3++uvq3bu36tevr549e+qqq65Sr169Ku2/OuN8dXly/5U50VhTVm9FM/6lpKSU+8PN7/V7jgvgVCH8AFXg4+Ojbt266emnn1ZWVpZatGhR7T6WLl0qSSoqKlJWVla5D3Y4PUpLS9WqVSs99dRTFb5+7Ifio898lK0vSdddd91xw8OxH/h9fX0rbHd0kDgZx+v3RNsrew+PP/640tPTK2xbFkRHjRqlWbNmKTMzU506dVJERIRcLpcGDhzodsP1RRddpK1bt+rNN9/U+++/r7///e+aPHmyZsyYoRtvvFGSnEkwjnW8ST+Ot+///Oc/KyMjo8J1jv1QV519dHRtpaWliomJ0SuvvFLh+sd+GP09P2OXy6WFCxdq7dq1evvtt7V06VLdcMMNevLJJ7V27dpyfxQ41TIzM9W3b18tXrxYS5cu1dixYzVx4kR99NFHatu2bbX6Ki0t1SWXXKIxY8ZU+HrZh/2TVdX+Y2JitH79ei1dulTvvvuu3n33Xc2aNUuDBg1ymwSmpqnu/vPkWHO8P9BVNknPsU7V2Af8HoQfoIqKi4slSQUFBZKkhIQEffjhhzpw4IDbXwU3btzovF7mq6++0oMPPqihQ4dq/fr1uvHGG/X11187f4U+kaysLHXr1s15XlBQoN27d+sPf/jDcddJSEjQV199pdLSUrezP8fWV91v5U5ISNCmTZvKLa/ofVenz2XLlqmgoMDtg15F2/m9kpOTtWHDBnXv3v2kvpE8OjpaYWFhKikpUY8ePTxW1+n8dvSyy1DCw8NP+B4WLlyowYMH68knn3SWFRUVVTgTX1RUlIYOHaqhQ4eqoKBAF110kcaPH++En8jIyAovd6nqX88bN24s6bfLNz257yuSnJysDz/8UBdccEG5EHayTvQz7tixozp27Ki//e1vmjdvnv70pz/ptddec/bfscqOtU2bNjn7RpIOHz6s7Ozs37WPkpOTddddd+muu+5SVlaW0tPT9eSTT7p9Z1fZmbij39fmzZslybkcMzk5WQUFBSesJTk5WUuXLtUvv/xSrbM/Ve1f+u2MWN++fdW3b1+Vlpbqtttu0/PPP6+xY8ce97uPqjPOV5cn919VldV79GyTR9dztLKzRsce67/nbBdQE3DPD1AFR44c0fvvv6+AgADncoc//OEPKikp0bPPPuvWdvLkyXK5XOrdu7ez7pAhQxQfH6+nn35as2fPVk5Oju68884qb3/mzJlu9wJMnz5dxcXFzjYq8oc//EF79uzR/PnznWXFxcWaOnWqQkND1aVLF0lyvum9og+zx+v3P//5j9asWeMsKyws1MyZM5WYmHhS36vzhz/8QcXFxZo+fbqzrKSkRFOnTq12Xydy1VVXaefOnXrhhRfKvXbw4EEVFhZWur6vr68GDBigN954Q99880251/fu3XtSdYWEhLhdRnYqtWvXTsnJyXriiSecMH+0o9+Dr69vub/STp06tdxff3/++We356GhoUpJSXGbPjw5OVkbN25063/Dhg3lptc+npiYGHXt2lXPP/+8du/eXWndv9dVV12lkpISPfTQQ+VeKy4urvLxcrSQkBBJ5Y+1ffv2ldvHZWfkjp1+/Wg9evRQQECAnnnmGbf1//GPfygvL0+XXnpptWv89ddfVVRU5LYsOTlZYWFh5WrZtWuXFi1a5DzPz8/XnDlzlJ6e7lwid9VVV2nNmjXOme+j7d+/3/mj0oABA2SM0YQJE8q1q+wsQVX7P/b308fHxzlDW9k+ruo4fzI8uf+qKj4+Xi1bttScOXPcjv2VK1c60+SXSUhIkK+vb7n7ip577rlqbROoaTjzA1Tg3Xffdf6yl5ubq3nz5ikrK0v33HOPwsPDJUl9+/ZVt27d9Ne//lXbtm1TmzZt9P777+vNN99UZmam89f1hx9+WOvXr9eyZcsUFham1q1b64EHHtD999+vK664otKzN2UOHz6s7t2766qrrtKmTZv03HPPqXPnzvrjH/943HWGDx+u559/XkOGDNHnn3+uxMRELVy4UJ988ommTJni/BUzODhYzZs31/z589W0aVNFRUWpZcuWx71v55577tGrr76q3r176/bbb1dUVJReeuklZWdn64033ih3j1FV9O3bVxdccIHuuecebdu2zfm+i1MRBq6//nq9/vrruuWWW7R8+XJdcMEFKikp0caNG/X6669r6dKlbvd7VeTRRx/V8uXL1aFDB910001q3ry5fvnlF33xxRf68MMP9csvv1S7rnbt2mn+/PkaPXq0zjvvPIWGhqpv374n+zYr5ePjo7///e/q3bu3WrRooaFDh6p+/frauXOnli9frvDwcL399tuSpD59+mju3LmKiIhQ8+bNtWbNGn344YeqU6eOW5/NmzdX165d1a5dO0VFRemzzz7TwoULNXLkSKfNDTfcoKeeekoZGRkaNmyYcnNzNWPGDLVo0UL5+flVqn3atGnq3LmzWrVqpZtuukmNGzdWTk6O1qxZox9//FEbNmzwyD7q0qWLbr75Zk2cOFHr169Xz5495e/vr6ysLC1YsEBPP/20rrjiimr1mZ6eLl9fXz322GPKy8tTYGCgLr74Ys2bN0/PPfecLrvsMiUnJ+vAgQN64YUXFB4eXun4EB0drXvvvVcTJkxQr1699Mc//tEZH8477zxdd9111X7fmzdvdsaa5s2by8/PT4sWLVJOTo4GDhzo1rZp06YaNmyYPv30U8XGxurFF19UTk6OZs2a5bT5y1/+orfeekt9+vTRkCFD1K5dOxUWFurrr7/WwoULtW3bNtWtW1fdunXT9ddfr2eeeUZZWVnq1auXSktL9fHHH6tbt25uv0dHq2r/N954o3755RddfPHFatCggbZv366pU6cqPT3d+YNWRao6zp8MT+6/6njkkUfUr18/XXDBBRo6dKj27dunZ599Vi1btnQLRBEREbryyis1depUuVwuJScna8mSJeXuMwLOOKd1bjmghqtoquugoCCTnp5upk+f7jblqjG/TfF85513mvj4eOPv72+aNGliHn/8cafd559/bvz8/MyoUaPc1isuLjbnnXeeiY+PN/v27TthPStXrjTDhw83kZGRJjQ01PzpT38yP//8s1vbiqYRzsnJMUOHDjV169Y1AQEBplWrVm7Tk5b597//bdq1a2cCAgKqNO311q1bzRVXXGFq165tgoKCTPv27c2SJUvKtVMVp7o2xpiff/7ZXH/99SY8PNxERESY66+/3nz55Zcen+ramN+m/H7sscdMixYtTGBgoImMjDTt2rUzEyZMMHl5eVWqPycnx4wYMcI0bNjQ+Pv7m7i4ONO9e3czc+ZMp03ZVLELFixwW7eiqWILCgrMtddea2rXrl1uytmKVFRbWb/HTlN8vDq+/PJLc/nll5s6deqYwMBAk5CQYK666iqzbNkyp82+ffuc36HQ0FCTkZFhNm7cWG7K4Ycffti0b9/e1K5d2wQHB5vU1FTzt7/9zW2KdmOMefnll03jxo1NQECASU9PN0uXLj3uVNfHm25569atZtCgQSYuLs74+/ub+vXrmz59+piFCxc6bcqOnWOnjz7elM+DBw82ISEh5bY1c+ZM065dOxMcHGzCwsJMq1atzJgxY8yuXbucNsf7PavomHzhhRdM48aNja+vrzON8BdffGGuueYa06hRIxMYGGhiYmJMnz59zGeffVbh+z/Ws88+a1JTU42/v7+JjY01t956a7lxpapTXf/0009mxIgRJjU11YSEhJiIiAjToUMH8/rrr7u1K3vPS5cuNa1btzaBgYEmNTW13O+YMb+Nk/fee69JSUkxAQEBpm7duub88883TzzxhNvvR3FxsXn88cdNamqqCQgIMNHR0aZ3797m888/d9vu0b93Ve1/4cKFpmfPniYmJsYEBASYRo0amZtvvtns3r37hPv3RON8mepOde3J/VfZMVPRmP7aa6+Z1NRUExgYaFq2bGneeustM2DAAJOamurWbu/evWbAgAGmVq1aJjIy0tx8883mm2++qfJU1xWNnxX9DIHTyWUMd50BNdXs2bM1dOhQffrppyc8GwEAp0tiYqJatmypJUuWeLuUM1JN3H/p6emKjo6u9nTgwJmGe34AAAAsceTIkXL3Cq1YsUIbNmxQ165dvVMUcBpxzw8AAIAldu7cqR49eui6665TfHy8Nm7cqBkzZiguLk633HKLt8sDTjnCDwAAgCUiIyPVrl07/f3vf9fevXsVEhKiSy+9VI8++mi5iUyAsxH3/AAAAACwAvf8AAAAALAC4QcAAACAFc7Ie35KS0u1a9cuhYWFyeVyebscAAAAAF5ijNGBAwcUHx9/wi9bPyPDz65du9SwYUNvlwEAAACghvjhhx/UoEGDStuckeEnLCxM0m9vMDw83MvVAAAAAPCW/Px8NWzY0MkIlTkjw0/ZpW7h4eGEHwAAAABVuh2GCQ8AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAAr+Hm7AAAAANjl4OESbd1b4JG+io6U6Md9B9UgMlhB/r4e6VOSkqNDFRzguf5QMxB+AAAAcFpt3VugPlNXe7uMSi0Z1Vkt60d4uwx4GOEHAAAAp1VydKiWjOrskb625BYoc/56Tbk6XSkxoR7pU/qtRpx9CD8AAAA4rYIDfD1+ViUlJpQzNTghJjwAAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAK/h5uwAAAADUfNk/FarwULG3yyhnS26B239rmpBAPyXVDfF2Gfgvwg8AAAAqlf1Tobo9scLbZVQqc/56b5dwXMv/3JUAVEMQfgAAAFCpsjM+U65OV0pMqJercVd0pEQ/7juoBpHBCvL39XY5brbkFihz/voaecbMVoQfAAAAVElKTKha1o/wdhnlnJvo7QpwpmDCAwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVqhV+Jk6cqPPOO09hYWGKiYlR//79tWnTJrc2xhg98MADqlevnoKDg9WjRw9lZWW5tSkqKtKIESNUp04dhYaGasCAAcrJyfn97wYAAAAAjqNa4WflypUaMWKE1q5dqw8++EBHjhxRz549VVhY6LSZNGmSnnnmGc2YMUPr1q1TSEiIMjIyVFRU5LS588479fbbb2vBggVauXKldu3apcsvv9xz7woAAAAAjuFXncbvvfee2/PZs2crJiZGn3/+uS666CIZYzRlyhTdf//96tevnyRpzpw5io2N1eLFizVw4EDl5eXpH//4h+bNm6eLL75YkjRr1iylpaVp7dq16tixo4feGgAAAAD8z++65ycvL0+SFBUVJUnKzs7Wnj171KNHD6dNRESEOnTooDVr1kiSPv/8cx05csStTWpqqho1auS0OdahQ4eUn5/v9gAAAACA6jjp8FNaWqrMzExdcMEFatmypSRpz549kqTY2Fi3trGxsc5re/bsUUBAgGrXrn3cNseaOHGiIiIinEfDhg1PtmwAAAAAljrp8DNixAh98803eu211zxZT4Xuvfde5eXlOY8ffvjhlG8TAAAAwNnlpMLPyJEjtWTJEi1fvlwNGjRwlsfFxUlSuZnbcnJynNfi4uJ0+PBh7d+//7htjhUYGKjw8HC3BwAAAABUR7XCjzFGI0eO1KJFi/TRRx8pKSnJ7fWkpCTFxcVp2bJlzrL8/HytW7dOnTp1kiS1a9dO/v7+bm02bdqkHTt2OG0AAAAAwNOqNdvbiBEjNG/ePL355psKCwtz7tGJiIhQcHCwXC6XMjMz9fDDD6tJkyZKSkrS2LFjFR8fr/79+ztthw0bptGjRysqKkrh4eEaNWqUOnXqxExvAAAAAE6ZaoWf6dOnS5K6du3qtnzWrFkaMmSIJGnMmDEqLCzU8OHDtX//fnXu3FnvvfeegoKCnPaTJ0+Wj4+PBgwYoEOHDikjI0PPPffc73snAAAAAFCJaoUfY8wJ27hcLj344IN68MEHj9smKChI06ZN07Rp06qzeQAAAAA4adUKPwAAALDPoZIi+QTtVHb+JvkEhXq7nDNGdn6BfIJ26lBJkaQIb5cDEX4AAABwArsKtyskaaru+4+3KznzhCRJuwrT1U6xJ26MU47wAwAAgErFhySoMHuUnr46XckxnPmpqq25Bbpj/nrFd0vwdin4L8IPAAAAKhXoG6TSovpKCm+m5nW4fKuqSovyVFq0V4G+QSdujNPipL7kFAAAAADONIQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBT9vFwAAAICa7eCREknSNzvzvFxJeUVHSvTjvoNqEBmsIH9fb5fjZktugbdLwDEIPwAAAKjU1v9+iL/nn197uZIzU0ggH7lrCn4SAAAAqFTPFnGSpOSYUAXXwLMrmfPXa8rV6UqJCfV2OeWEBPopqW6It8vAfxF+AAAAUKmokAANbN/I22VUKiUmVC3rR3i7DNRwTHgAAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAVvDzdgEAAACwy8HDJdq6t8AjfW3JLXD7r6ckR4cqOMDXo33C+wg/AAAAOK227i1Qn6mrPdpn5vz1Hu1vyajOalk/wqN9wvsIPwAAADitkqNDtWRUZ4/0VXSkRD/uO6gGkcEK8vfcmZrk6FCP9YWag/ADAACA0yo4wNejZ1XOTfRYVzjLMeEBAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACtUO/ysWrVKffv2VXx8vFwulxYvXuz2+pAhQ+RyudwevXr1cmtTVFSkESNGqE6dOgoNDdWAAQOUk5Pzu94IAAAAAFSm2uGnsLBQbdq00bRp047bplevXtq9e7fzePXVV91ev/POO/X2229rwYIFWrlypXbt2qXLL7+8+tUDAAAAQBX5VXeF3r17q3fv3pW2CQwMVFxcXIWv5eXl6R//+IfmzZuniy++WJI0a9YspaWlae3aterYsWN1SwIAAACAEzol9/ysWLFCMTExatasmW699Vb9/PPPzmuff/65jhw5oh49ejjLUlNT1ahRI61Zs6bC/g4dOqT8/Hy3BwAAAABUh8fDT69evTRnzhwtW7ZMjz32mFauXKnevXurpKREkrRnzx4FBASodu3abuvFxsZqz549FfY5ceJERUREOI+GDRt6umwAAAAAZ7lqX/Z2IgMHDnT+v1WrVmrdurWSk5O1YsUKde/e/aT6vPfeezV69GjneX5+PgEIAAAAQLWc8qmuGzdurLp162rLli2SpLi4OB0+fFj79+93a5eTk3Pc+4QCAwMVHh7u9gAAAACA6jjl4efHH3/Uzz//rHr16kmS2rVrJ39/fy1btsxps2nTJu3YsUOdOnU61eUAAAAAsFS1L3srKChwzuJIUnZ2ttavX6+oqChFRUVpwoQJGjBggOLi4rR161aNGTNGKSkpysjIkCRFRERo2LBhGj16tKKiohQeHq5Ro0apU6dOzPQGAAAA4JSpdvj57LPP1K1bN+d52b04gwcP1vTp0/XVV1/ppZde0v79+xUfH6+ePXvqoYceUmBgoLPO5MmT5ePjowEDBujQoUPKyMjQc88954G3AwAAAAAVcxljjLeLqK78/HxFREQoLy+P+38AAAAAi1UnG5zye34AAAAAoCYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAK1Q7/KxatUp9+/ZVfHy8XC6XFi9e7Pa6MUYPPPCA6tWrp+DgYPXo0UNZWVlubYqKijRixAjVqVNHoaGhGjBggHJycn7XGwEAAACAylQ7/BQWFqpNmzaaNm1aha9PmjRJzzzzjGbMmKF169YpJCREGRkZKioqctrceeedevvtt7VgwQKtXLlSu3bt0uWXX37y7wIAAAAATsBljDEnvbLLpUWLFql///6SfjvrEx8fr7vuukt//vOfJUl5eXmKjY3V7NmzNXDgQOXl5Sk6Olrz5s3TFVdcIUnauHGj0tLStGbNGnXs2PGE283Pz1dERITy8vIUHh5+suUDAAAAOMNVJxt49J6f7Oxs7dmzRz169HCWRUREqEOHDlqzZo0k6fPPP9eRI0fc2qSmpqpRo0ZOm2MdOnRI+fn5bg8AAAAAqA6Php89e/ZIkmJjY92Wx8bGOq/t2bNHAQEBql279nHbHGvixImKiIhwHg0bNvRk2QAAAAAscEbM9nbvvfcqLy/Pefzwww/eLgkAAADAGcaj4ScuLk6Sys3clpOT47wWFxenw4cPa//+/cdtc6zAwECFh4e7PQAAAACgOjwafpKSkhQXF6dly5Y5y/Lz87Vu3Tp16tRJktSuXTv5+/u7tdm0aZN27NjhtAEAAAAAT/Or7goFBQXasmWL8zw7O1vr169XVFSUGjVqpMzMTD388MNq0qSJkpKSNHbsWMXHxzszwkVERGjYsGEaPXq0oqKiFB4erlGjRqlTp05VmukNAAAAAE5GtcPPZ599pm7dujnPR48eLUkaPHiwZs+erTFjxqiwsFDDhw/X/v371blzZ7333nsKCgpy1pk8ebJ8fHw0YMAAHTp0SBkZGXruuec88HYAAAAAoGK/63t+vIXv+QEAAAAgefF7fgAAAACgpiL8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKft4uAPY4eLhEW/cWeKy/oiMl+nHfQTWIDFaQv69H+kyODlVwgGf6AgAAQM1C+MFps3VvgfpMXe3tMiq1ZFRntawf4e0yAAAAcAoQfnDaJEeHasmozh7rb0tugTLnr9eUq9OVEhPqkT6Toz3TDwAAAGoewg9Om+AA31NyViUlJpSzNQAAADghJjwAAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFj4ef8ePHy+VyuT1SU1Od140xeuCBB1SvXj0FBwerR48eysrK8nQZAAAAAODmlJz5adGihXbv3u08Vq9e7bw2adIkPfPMM5oxY4bWrVunkJAQZWRkqKio6FSUAgAAAACSJL9T0qmfn+Li4sotN8ZoypQpuv/++9WvXz9J0pw5cxQbG6vFixdr4MCBp6IcAAAAADg1Z36ysrIUHx+vxo0b609/+pN27NghScrOztaePXvUo0cPp21ERIQ6dOigNWvWHLe/Q4cOKT8/3+0BAAAAANXh8fDToUMHzZ49W++9956mT5+u7OxsXXjhhTpw4ID27NkjSYqNjXVbJzY21nmtIhMnTlRERITzaNiwoafLBgAAAHCW8/hlb71793b+v3Xr1urQoYMSEhL0+uuvKy0t7aT6vPfeezV69GjneX5+PgEIAAAAQLWc8qmua9euraZNm2rLli3OfUA5OTlubXJyciq8R6hMYGCgwsPD3R4AAAAAUB2nZMKDoxUUFGjr1q26/vrrlZSUpLi4OC1btkzp6emSfjuLs27dOt16662nuhScpOyfClV4qNjbZZSzJbfA7b81SUign5Lqhni7DAAAABzF4+Hnz3/+s/r27auEhATt2rVL48aNk6+vr6655hq5XC5lZmbq4YcfVpMmTZSUlKSxY8cqPj5e/fv393Qp8IDsnwrV7YkV3i6jUpnz13u7hAot/3NXAhAAAEAN4vHw8+OPP+qaa67Rzz//rOjoaHXu3Flr165VdHS0JGnMmDEqLCzU8OHDtX//fnXu3FnvvfeegoKCPF0KPKDsjM+Uq9OVEhPq5WrcFR0p0Y/7DqpBZLCC/H29XY5jS26BMuevr5FnywAAAGzm8fDz2muvVfq6y+XSgw8+qAcffNDTm8YplBITqpb1I7xdRjnnJnq7AgAAAJwpTvmEBwAAAABQExB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACs4PHv+cHZ5VBJkXyCdio7f5N8gmrWl5zWVNn5BfIJ2qlDJUWSat53IwEAANiK8INK7SrcrpCkqbrvP96u5MwSkiTtKkxXO8V6uxQAAAD8F+EHlYoPSVBh9ig9fXW6kmM481MVW3MLdMf89YrvluDtUgAAAHAUwg8qFegbpNKi+koKb6bmdbiEqypKi/JUWrRXgb5B3i4FAAAAR2HCAwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFbw83YBqNkOHimRJH2zM8/LlZRXdKREP+47qAaRwQry9/V2OY4tuQXeLgEAAAAVIPygUlv/+0H+nn9+7eVKzjwhgRxeAAAANQmfzlCpni3iJEnJMaEKrkFnV6TfzrBkzl+vKVenKyUm1NvluAkJ9FNS3RBvlwEAAICjEH5QqaiQAA1s38jbZVQqJSZULetHeLsMAAAA1HBMeAAAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBT9vFwB7HDxcoq17CzzW35bcArf/ekJydKiCA3w91h8AAABqDsIPTputewvUZ+pqj/ebOX+9x/paMqqzWtaP8Fh/AAAAqDkIPzhtkqNDtWRUZ4/1V3SkRD/uO6gGkcEK8vfM2Zrk6FCP9AMAAICah/CD0yY4wNfjZ1XOTfRodwAAADiLMeEBAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABWIPwAAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBT9vFwAAsMfBwyXaurfAY/0VHSnRj/sOqkFksIL8fT3SZ3J0qIIDPNMXAKBmIfwAAE6brXsL1Gfqam+XUaklozqrZf0Ib5cBADgFCD8AgNMmOTpUS0Z19lh/W3ILlDl/vaZcna6UmFCP9Jkc7Zl+AAA1D+EHAHDaBAf4npKzKikxoZytAQCcEBMeAAAAALAC4QcAAACAFQg/AAAAAKzAPT8AgBPK/qlQhYeKvV1GOVtyC9z+W9OEBPopqW6It8sAAPwX4QcAUKnsnwrV7YkV3i6jUpnz13u7hONa/ueuBCAAqCEIPwCASpWd8fHkdNKeciq+5NRTyqbhrolnzADAVoQfAEClDpUUySdop3yDouUTVLPCT60gqWmYJOV5u5RyfIMK5BO0U4dKiiQxDTcA1ASEHwBApXYVbldI0lTd9x9vV3LmCUmSdhWmq51ivV0KAECEHwDACcSHJKgwe5SevjpdyTXssreabGtuge6Yv17x3RK8XQoA4L8IPwCASgX6Bqm0qL6SwpupeR0u36qq0qI8lRbtVaBvkLdLAQD8F9/zAwAAAMAKnPkBAFTq4JESSdI3O2vepAI1fbY3AEDNQvgBAFRq638/xN/zz6+9XMmZKSSQf2oBoKZgRAYAVKpnizhJUnJMqIJr4NmVzPnra+R3EEm/BR++4BQAag7CDwCgUlEhARrYvpG3y6hUSkyoWtZnMgYAQOWY8AAAAACAFQg/AAAAAKzAZW8AgNPm4OESbd3ruVnQymZU8+TMasnRoQoOqFn3NgEAPIPwAwA4bbbuLVCfqas93m/m/PUe62vJqM7cPwQAZynCDwDgtEmODtWSUZ091t+p+J6f5OiaN2scAMAzCD8AgNMmOMDX42dVzk30aHcAgLMYEx4AAAAAsALhBwAAAIAVCD8AAAAArED4AQAAAGAFwg8AAAAAKxB+AAAAAFiB8AMAAADACoQfAAAAAFYg/AAAAACwAuEHAAAAgBUIPwAAAACsQPgBAAAAYAXCDwAAAAArEH4AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACsQfgAAAABYgfADAAAAwAqEHwAAAABW8PN2ASfDGCNJys/P93IlAAAAALypLBOUZYTKnJHh58CBA5Kkhg0berkSAAAAADXBgQMHFBERUWkbl6lKRKphSktLtWvXLoWFhcnlcnm7HHhJfn6+GjZsqB9++EHh4eHeLgeAFzAOAGAcgDFGBw4cUHx8vHx8Kr+r54w88+Pj46MGDRp4uwzUEOHh4Qx2gOUYBwAwDtjtRGd8yjDhAQAAAAArEH4AAAAAWIHwgzNWYGCgxo0bp8DAQG+XAsBLGAcAMA6gOs7ICQ8AAAAAoLo48wMAAADACoQfAAAAAFYg/AAAAACwAuHHMl27dlVmZuZxX09MTNSUKVOc5y6XS4sXL5Ykbdu2TS6XS+vXrz/hdlasWCGXy6X9+/f/rno95UTvG7DR6RoPKnI6x4jx48crPT39lG8H8DZjjIYPH66oqCi5XC7Vrl3b7Rg/9piuyY4eb7yNMeTsQviBm08//VTDhw/3dhknraaFLuBMdiaOBzXpAxNwur333nuaPXu2lixZot27d6tly5Zur5+Jx/Tpxhhy9vPzdgGoWaKjo71dAoAagvEAOLNs3bpV9erV0/nnny9J8vNz/5hXU47pw4cPKyAgwNtlwFKc+bFQcXGxRo4cqYiICNWtW1djx45V2Yznp/KU+OrVq3XhhRcqODhYDRs21O23367CwkLn9cTERD3yyCO64YYbFBYWpkaNGmnmzJluffz73/9Wenq6goKCdO6552rx4sXOpTfbtm1Tt27dJEmRkZFyuVwaMmSIs25paanGjBmjqKgoxcXFafz48VWu3eVy6fnnn1efPn1Uq1YtpaWlac2aNdqyZYu6du2qkJAQnX/++dq6dauzTtlp8hdffFGNGjVSaGiobrvtNpWUlGjSpEmKi4tTTEyM/va3v53cDgU84HSNB++8846aNm2q4OBgdevWTdu2bSvXpipjxEMPPaRrrrlGISEhql+/vqZNm+b2uiRddtllcrlczvMyc+fOVWJioiIiIjRw4EAdOHCgSrV37dpVo0aNUmZmpiIjIxUbG6sXXnhBhYWFGjp0qMLCwpSSkqJ3333XWafsLPTSpUvVtm1bBQcH6+KLL1Zubq7effddpaWlKTw8XNdee61+/fXXqu9I4DiGDBmiUaNGaceOHRX+/ksVX8o6ffp09e7dW8HBwWrcuLEWLlzovF52eetrr72m888/X0FBQWrZsqVWrlzp1u8333yj3r17KzQ0VLGxsbr++uv1008/Oa937dpVI0eOVGZmpurWrauMjIxqv78ffvhBV111lWrXrq2oqCj169fPbRwZMmSI+vfvryeeeEL16tVTnTp1NGLECB05csRps3v3bl166aUKDg5WUlKS5s2b57ZPGEMsYWCVLl26mNDQUHPHHXeYjRs3mpdfftnUqlXLzJw50xhjTEJCgpk8ebLTXpJZtGiRMcaY7OxsI8l8+eWXJ9zO8uXLjSSzb98+Y4wxW7ZsMSEhIWby5Mlm8+bN5pNPPjFt27Y1Q4YMcdZJSEgwUVFRZtq0aSYrK8tMnDjR+Pj4mI0bNxpjjMnLyzNRUVHmuuuuM99++6155513TNOmTZ2aiouLzRtvvGEkmU2bNpndu3eb/fv3O+87PDzcjB8/3mzevNm89NJLxuVymffff79K+02SqV+/vpk/f77ZtGmT6d+/v0lMTDQXX3yxee+998x3331nOnbsaHr16uWsM27cOBMaGmquuOIK8+2335q33nrLBAQEmIyMDDNq1CizceNG8+KLLxpJZu3atVWqA/Ck0zUe7NixwwQGBprRo0c724mNjT2pMSIsLMxMnDjRbNq0yTzzzDPG19fXOY5zc3ONJDNr1iyze/duk5uba4z537F4+eWXm6+//tqsWrXKxMXFmfvuu6/K+yksLMw89NBDZvPmzeahhx4yvr6+pnfv3mbmzJlm8+bN5tZbbzV16tQxhYWFxpj/jYEdO3Y0q1evNl988YVJSUkxXbp0MT179jRffPGFWbVqlalTp4559NFHq1QHUJn9+/ebBx980DRo0MD5/e/SpYu54447nDYVHdN16tQxL7zwgtm0aZO5//77ja+vr/nuu++MMf87zhs0aGAWLlxovvvuO3PjjTeasLAw89NPPxljjNm3b5+Jjo429957r/n+++/NF198YS655BLTrVs3ZztlY81f/vIXs3HjRuff9cocPd4cPnzYpKWlmRtuuMF89dVX5rvvvjPXXnutadasmTl06JAxxpjBgweb8PBwc8stt5jvv//evP32227jmTHG9OjRw6Snp5u1a9eazz//3HTp0sUEBwc7+4QxxA6EH8t06dLFpKWlmdLSUmfZ3XffbdLS0owxpy78DBs2zAwfPtytzccff2x8fHzMwYMHnW1fd911zuulpaUmJibGTJ8+3RhjzPTp002dOnWc9sYY88ILL7jVdOx2j37fnTt3dlt23nnnmbvvvvuE78WY3/bD/fff7zxfs2aNkWT+8Y9/OMteffVVExQU5DwfN26cqVWrlsnPz3eWZWRkmMTERFNSUuIsa9asmZk4cWKV6gA86XSNB/fee69p3ry527K77777pMaIo//AYIwxV199tendu3eFNZap6Fj8y1/+Yjp06HDC2o0pP34UFxebkJAQc/311zvLdu/ebSSZNWvWGGP+NxZ9+OGHTpuJEycaSWbr1q3OsptvvtlkZGRUqQ7gRCZPnmwSEhKc51UJP7fccotbHx06dDC33nqrMeZ/x/nRH66PHDliGjRoYB577DFjjDEPPfSQ6dmzp1sfP/zwg/OHyLI62rZtW633cvSxPHfuXNOsWTO3serQoUMmODjYLF261BjzW/hJSEgwxcXFTpsrr7zSXH311cYYY77//nsjyXz66afO61lZWUbScce5MowhZxcue7NQx44d5XK5nOedOnVSVlaWSkpKTtk2N2zYoNmzZys0NNR5ZGRkqLS0VNnZ2U671q1bO//vcrkUFxen3NxcSdKmTZvUunVrBQUFOW3at29f5RqO7luS6tWr5/Rd3fVjY2MlSa1atXJbVlRUpPz8fGdZYmKiwsLC3No0b95cPj4+bsuqUwfgSadjPPj+++/VoUMHt2WdOnVye17VMeLY9Tp16qTvv//+hDUceyz+nuPf19dXderUKXf8SyrX57HjRq1atdS4cWO3ZRz/8KaqHFNHt/Hz89O5557rtNmwYYOWL1/uduympqZKktul4O3atTvpGjds2KAtW7YoLCzM2UZUVJSKiorcttGiRQv5+vo6z48+zjdt2iQ/Pz+dc845zuspKSmKjIysUg2MIWcPJjzAaVFQUKCbb75Zt99+e7nXGjVq5Py/v7+/22sul0ulpaUeqeH39n30+mUfFitadnSfFW3zVL5H4ExV1THiZHny+C9b/0TH/7HrcfzjbFRQUKC+ffvqscceK/davXr1nP8PCQn5Xdto166dXnnllXKvHT2Jw5nyGaJsfcYQ7yD8WGjdunVuz9euXasmTZq4/bXE08455xx99913SklJOek+mjVrppdfflmHDh1SYGCgpN+m7Txa2ewxp/IsFnA2OR3jQVpamt56661y2zlaVceIY9dbu3at0tLSnOf+/v4c/0A1rF27VoMGDXJ73rZt23JtLrroIkm/TZLy+eefa+TIkZJ+O3bfeOMNJSYmlptdzlPOOecczZ8/XzExMQoPDz+pPpo1a6bi4mJ9+eWXzlmoLVu2aN++fW7tGEPOflz2ZqEdO3Zo9OjR2rRpk1599VVNnTpVd9xxxynd5t13361///vfGjlypNavX6+srCy9+eabzuBZFddee61KS0s1fPhwff/991q6dKmeeOIJSf/7i0lCQoJcLpeWLFmivXv3qqCg4JS8H+BscTrGg1tuuUVZWVn6y1/+ok2bNmnevHmaPXu2W5uqjhGffPKJJk2apM2bN2vatGlasGCBW72JiYlatmyZ9uzZU+5DDYDyFixYoBdffFGbN2/WuHHj9J///KfccTdt2jQtWrRIGzdu1IgRI7Rv3z7dcMMNkqQRI0bol19+0TXXXKNPP/1UW7du1dKlSzV06FCPhYg//elPqlu3rvr166ePP/5Y2dnZWrFihW6//Xb9+OOPVeojNTVVPXr00PDhw/Wf//xHX375pYYPH67g4GC3S38ZQ85+hB8LDRo0SAcPHlT79u01YsQI3XHHHaf8S89at26tlStXavPmzbrwwgvVtm1bPfDAA4qPj69yH+Hh4Xr77be1fv16paen669//aseeOABSXLuA6pfv74mTJige+65R7GxsdUKV4CNTsd40KhRI73xxhtavHix2rRpoxkzZuiRRx5xa1PVMeKuu+7SZ599prZt2+rhhx/WU0895TZt7pNPPqkPPvhADRs2LPfXawDlTZgwQa+99ppat26tOXPm6NVXX1Xz5s3d2jz66KN69NFH1aZNG61evVpvvfWW6tatK0mKj4/XJ598opKSEvXs2VOtWrVSZmamateu7XZ/6+9Rq1YtrVq1So0aNdLll1+utLQ0DRs2TEVFRdU6EzRnzhzFxsbqoosu0mWXXaabbrpJYWFhbvcSM4ac/VzG/PcLHYAz0CuvvKKhQ4cqLy9PwcHB3i4HwCmUmJiozMxMZWZmersU4Kzgcrm0aNEi9e/fv8LXt23bpqSkJH355ZdKT08/rbWdDj/++KMaNmyoDz/8UN27d/d2OThNuOcHZ5Q5c+aocePGql+/vjZs2KC7775bV111FcEHAABU6qOPPlJBQYFatWql3bt3a8yYMUpMTHTuZ4IduOwNJ+WWW25xm9by6Mctt9xyyra7Z88eXXfddUpLS9Odd96pK6+8UjNnzvxdfb7yyivHfS8tWrTwUOXA2ctb44En7Nix47i1h4aGaseOHd4uETjreOvf3SNHjui+++5TixYtdNlllyk6OlorVqwoN4NadTCGnHm47A0nJTc31+37bI4WHh6umJiY01zRyTtw4IBycnIqfM3f318JCQmnuSLgzHImjwfFxcXatm3bcV8/lTNYAbY6m/7dZQw58xB+AAAAAFiBy94AAAAAWIHwAwAAAMAKhB8AAAAAViD8AAAAALAC4QcAAACAFQg/AAAAAKxA+AEAAABgBcIPAAAAACv8P4Xy08fnoMPaAAAAAElFTkSuQmCC" + }, + "metadata": {} + } ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "#### Making subplots" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], "source": [ "df.plot(kind='box',\n", " subplots=True, layout=(2,2),\n", " figsize=(10,8), title='Box plot of different measurements of species of penguin', legend=True)" + ], + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": 7, + "outputs": [ + { + "execution_count": 7, + "output_type": "execute_result", + "data": { + "text/plain": "bill_length_mm AxesSubplot(0.125,0.53;0.352273x0.35)\nbill_depth_mm AxesSubplot(0.547727,0.53;0.352273x0.35)\nflipper_length_mm AxesSubplot(0.125,0.11;0.352273x0.35)\nbody_mass_g AxesSubplot(0.547727,0.11;0.352273x0.35)\ndtype: object" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {} + } ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -207,193 +319,241 @@ "Exercise: Compare bill length of different species of penguin\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - "Let's use box plot to compare the bill length of different species of penguin. We need the DataFrame to be slightly different so we can compare the different type species of penguin. We would like to pivot the data so each column are bill length of different species of penguin." - ] + "Let's use box plot to compare the bill length of different species of penguin. We need the DataFrame to be slightly different so we can compare the different species of penguin. We would like to pivot the data so each column are bill length of different species of penguin." + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "#### Prepare the data set" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df_pivot = df.pivot(index=None, columns='species', values='bill_length_mm')\n", + "# tell the pivot() method to make the 'species' as columns, and using the 'bill_length_mm' as the value" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df_pivot = df.pivot(index=None, columns='species', values='bill_length_mm')\n", - "# tell the pivot() method to make the 'species' as columns, and using the 'bill_length_mm' as the value" - ] + "execution_count": 8, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df_pivot.sample(10)" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df_pivot.sample(10)" + "execution_count": 9, + "outputs": [ + { + "execution_count": 9, + "output_type": "execute_result", + "data": { + "text/plain": "species Adelie Chinstrap Gentoo\n200 NaN 51.5 NaN\n180 NaN 46.4 NaN\n136 35.6 NaN NaN\n30 39.5 NaN NaN\n199 NaN 49.0 NaN\n337 NaN NaN 48.8\n165 NaN 52.0 NaN\n129 44.1 NaN NaN\n194 NaN 50.9 NaN\n155 NaN 45.4 NaN", + "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
speciesAdelieChinstrapGentoo
200NaN51.5NaN
180NaN46.4NaN
13635.6NaNNaN
3039.5NaNNaN
199NaN49.0NaN
337NaNNaN48.8
165NaN52.0NaN
12944.1NaNNaN
194NaN50.9NaN
155NaN45.4NaN
\n
" + }, + "metadata": {} + } ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "#### Box plot of df_pivot\n", "\n", "Now we can use `plot()` on `df_pivot`. To make a box plot, remember to set the parameter `kind` to 'box'. Also make the presentation nice by setting a good `figsize` and with a good `title`. Don't forget the `legend`." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "#### Additional exercise\n", "\n", "Challenge yourself by making your own `df_pivot` pivoting on a different measure (e.g. Body Mass). Also try using a histogram (hist) instead of a boxplot. You can also try making a plot with 3 subplots, each is a histogram of a type of penguin." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "So far we are not using `matplotlib.pyplot` directly. Although it is very convenient to use `df.plot()`, sometimes we would like to have more control with what we are plotting and make more complex graphs. In the following sections, we will use `matplotlib.pyplot` (which is imported as `plt` now) directly." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - "### Divide the data into 3 types accordingly" - ] + "### Divide the data into 3 types accordingly\n", + "\n", + "In order to create the following plots, we need to create different pandas DataFrames for each penguin species." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df['species'].unique()" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df['species'].unique()" + "execution_count": 10, + "outputs": [ + { + "execution_count": 10, + "output_type": "execute_result", + "data": { + "text/plain": "array(['Adelie', 'Chinstrap', 'Gentoo'], dtype=object)" + }, + "metadata": {} + } ] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df_adelie = df[df['species'] == 'Adelie']" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df_adelie = df[df['species'] == 'Adelie']" - ] + "execution_count": 11, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df_chinstrap = df[df['species'] == 'Chinstrap']" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df_chinstrap = df[df['species'] == 'Chinstrap']" - ] + "execution_count": 12, + "outputs": [] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "df_gentoo = df[df['species'] == 'Gentoo']" + ], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false, + "trusted": true }, - "outputs": [], - "source": [ - "df_gentoo = df[df['species'] == 'Gentoo']" - ] + "execution_count": 13, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Scatter plot example: plot on Bill Length and Width" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], "source": [ "plt.scatter(df_adelie['bill_length_mm'], df_adelie['bill_depth_mm'], c='r')\n", "plt.scatter(df_chinstrap['bill_length_mm'], df_chinstrap['bill_depth_mm'], c='g')\n", "plt.scatter(df_gentoo['bill_length_mm'], df_gentoo['bill_depth_mm'], c='b')" + ], + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": 14, + "outputs": [ + { + "execution_count": 14, + "output_type": "execute_result", + "data": { + "text/plain": "" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {} + } ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "#### Better presentation: figure size, add labels and legend" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], "source": [ "plt.figure(figsize=(10,8)) # set the size of the plot\n", "\n", @@ -408,44 +568,64 @@ "ax.set_title('Bill Length and Width for Different Species of Penguin')\n", "\n", "ax.legend(('adelie', 'chinstrap', 'gentoo'))" + ], + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": 16, + "outputs": [ + { + "execution_count": 16, + "output_type": "execute_result", + "data": { + "text/plain": "" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {} + } ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Scatter plot exercise: plot on Flipper Length and Body Mass\n", "\n", - "Now is your turn to make your own plot. Make sure you have also set the labels and legend" - ] + "Now is your turn to make your own plot. Make sure you have also set the labels and legend." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Histogram example: plot on Bill Length" - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], "source": [ "plt.figure(figsize=(10,8))\n", "\n", @@ -459,48 +639,68 @@ "ax.set_title('Histogram of Bill Length for Different Species of Penguin')\n", "\n", "ax.legend(('adelie', 'chinstrap', 'gentoo'))" + ], + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": 17, + "outputs": [ + { + "execution_count": 17, + "output_type": "execute_result", + "data": { + "text/plain": "" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {} + } ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Histogram exercise: plot on Body Mass\n", "\n", "Now is your turn to make your own plot. Make sure you set the alpha to a proper value and have the right the labels and legend." - ] + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, + "source": [], "metadata": { "jupyter": { "outputs_hidden": false - } + }, + "collapsed": false }, - "outputs": [], - "source": [] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Making subplots example\n", "\n", - "To make subplots with just `plt` is a bit more complicated. It is considered more advance and require some understanding of what the building blocks are in a plot. Don't feel bad if you find it challenging, you can always follow the example and try it yourself to understand more what is going on.\n", + "To make subplots with just `plt` is a bit more complicated. It is considered more advanced and requires some understanding of what the building blocks are in a plot. Don't feel bad if you find it challenging, you can always follow the example and try it yourself to understand more of what is going on.\n", "\n", - "The example below plot the histogram of Bill Length and Bill Width side by side" - ] + "The example below plots the histogram of Bill Length and Bill Width side by side." + ], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], "source": [ "# First, we have to decide how many subplots we want and how they are orientated\n", "# say we want them side by side (i.e. 1 row 2 columns)\n", @@ -535,11 +735,28 @@ "ax1.legend(('adelie', 'chinstrap', 'gentoo'))\n", "\n", "plt.show() # after building what we want for both axes, use show() method to show plots" + ], + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {} + } ] }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -547,18 +764,18 @@ "Making subplots exercise\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Make 2 subplots, one on top of another. They are scatter plots of Flipper Length and Body Mass (with different type of penguin). After you have done it, try also other orientation and plots. See if you can make 4 subplots together. Always make sure the presentation is good." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "---\n", "\n", @@ -566,13 +783,13 @@ "More matplotlib!\n", "
\n", "" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - "Check out more example of histogram with multiple data sets: https://matplotlib.org/gallery/statistics/histogram_multihist.html#sphx-glr-gallery-statistics-histogram-multihist-py\n", + "Check out more examples of histogram with multiple data sets: https://matplotlib.org/gallery/statistics/histogram_multihist.html#sphx-glr-gallery-statistics-histogram-multihist-py\n", "\n", "Example: Creates histogram from scatter plot and adds them to the sides of the plot\n", "https://matplotlib.org/gallery/lines_bars_and_markers/scatter_hist.html#sphx-glr-gallery-lines-bars-and-markers-scatter-hist-py\n", @@ -582,28 +799,8 @@ "Also, if you are stuck, always check the documentation: https://matplotlib.org/api/_as_gen/matplotlib.pyplot.html#module-matplotlib.pyplot\n", "\n", "![](https://media0.giphy.com/media/l3nF8lOW9D0ZElDvG/200.gif)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (system-wide)", - "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.5" + ], + "metadata": {} } - }, - "nbformat": 4, - "nbformat_minor": 4 + ] } diff --git a/content/notebooks/3.2 Visualization with Seaborn.ipynb b/content/notebooks/3.2 Visualization with Seaborn.ipynb index 574cd4a..de829e9 100644 --- a/content/notebooks/3.2 Visualization with Seaborn.ipynb +++ b/content/notebooks/3.2 Visualization with Seaborn.ipynb @@ -1,420 +1,335 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
\n", - "

\n", - "

\n", - "

\n", - "Data visualization with Seaborn\n", - "

\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## About seaborn\n", - "Seaborn is a Python data visualization library based on matplotlib. It provides a high-level interface for drawing attractive and informative statistical graphics, which is very powerful for visualizing categorical data.\n", - "\n", - "![](https://d1rwhvwstyk9gu.cloudfront.net/2017/07/seaburn-1.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will be using the [Pokemon.csv](https://gist.github.com/armgilles/194bcff35001e7eb53a2a8b441e8b2c6). Let's have a look at the data:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "import pandas as pd\n", - "\n", - "pokemon_df = pd.read_csv('../data/Pokemon/pokemon.csv', index_col=0)\n", - "pokemon_df.head(10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "\n", - "

\n", - "Categorical scatterplots\n", - "


\n", - "
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For example, we want to compare the Attack of different type of Pokemon, to see if any type is generally more powerful than the others:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "\n", - "sns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "When import, we usually simplify 'seaborn' as 'sns'. (It's a [West Wing / Rob Lowe](https://en.wikipedia.org/wiki/Sam_Seaborn) reference!) Note that we have to also have to import matplotlib.pyplot because Seaborn is a library that sit on top of matplotlib. We got a plot but it looks ugly and not readable, let's add some configuration to make it nicer." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Try: adding `aspect=2.5` as the last arguments in the following `sns.catplot`**" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "sns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "So you can see that by adding 'aspect' we make the plot wider. The width of the plot is equal to 'aspect * height' so by adding 'aspect' we increase the width of the plot. It is one of the configuration we can add to the plot. For the whole list and their details, we can refer to the [official documentation](https://seaborn.pydata.org/generated/seaborn.catplot.html#seaborn.catplot) but we will give an introduction to a few common ones." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For example, here we see that there's a random x-axis offset for all the points so we can see them without dots overlapping each other. This is done by the 'jitter' setting which is default to True. Let's turn it off and see how it looks like:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Try: adding `jitter=False` as the last arguments in the following `sns.catplot`**" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "sns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df, aspect=2.5);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "So we now have a plot that points are align according to their catagories without the x-axis offsets. Which one to use is depending on if the population of the value (e.g. Attack) is important. In our case, we want to know how the Attack is distributed in each Type so many be it's good to have 'jitter' on, or even better if we can spread it out even more and show the distribution:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Try: adding `kind=\"swarm\"` as the last arguments in the following `sns.catplot`**" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "sns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df, aspect=2.5);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we can do it by setting 'kind' to 'swarm' so the points are not overlapping. The disadvantage is that this ploy will need more space horizontally. Imagine we don't want to make the plot super wide due to the limitation of the paper. We can turn it 90 degrees by flipping the x and the y,also we would adjust the aspect and the height:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Try: swap `x` and `y`, and add `height=12, aspect=0.6, kind=\"swarm\"` in the arguments of the following `sns.catplot`**" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "sns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "There are a few thing we can observe so far:\n", - "\n", - "1. For some Types, like Psychic has a very large range of Attack with a long tail the end (i.e. some Physic Types has very high Attack power while most of the Psychic type does not).\n", - "\n", - "2. On the other hand, the Poison type are mostly in the range of 40-110 Attacks.\n", - "\n", - "3. In general Dragon Types have more Attack power than Fairy, but there are 2 Fairy type that has more attack power." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "However, we would like to look deeper: I have a theory that Legendary Pokemon are more powerful. let's colour code according to 'Legendary' to see if the pokemon is Legendary or not will have something to do with the Attack of the pokemon:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Try: adding `hue=\"Legendary\"` as the last arguments in the following `sns.catplot`**" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false + "metadata": { + "kernelspec": { + "name": "python", + "display_name": "Python (Pyodide)", + "language": "python" + }, + "language_info": { + "codemirror_mode": { + "name": "python", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8" } - }, - "outputs": [], - "source": [ - "plt.figure(figsize=(15, 6))\n", - "sns.stripplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df, size=7)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Ah ha! We see that a lot of the Psychic Type that has higher that others in Attack is actually Legendary pokemon. That also happen to the Ground Type and the Flying type." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise\n", - "Now it's your turn to do some analysis. Pick a property of the Pokemon: HP, Defense, Sp. Atk, Sp. Def or Speed and do the similar analysis as above to see if you can find any interesting facts about Pokemon." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "\n", - "

\n", - "Building structured multi-plot grids\n", - "


\n", - "
" - ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Sometimes, we would have multiple plots in one graph for comparison. One way to do it in seaborn is to use FacetGrid. The FacetGrid class is useful when you want to visualize the distribution of a variable or the relationship between multiple variables separately within subsets of your dataset. In the following, we will be using FacetGrid to see if there is a difference for our analysis above across different Generations." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To make a FacetGrid, we can do the following:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "g = sns.FacetGrid(pokemon_df, col=\"Generation\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Look we have 6 plot areas which match as the number of different of Generations that we have\n", - "(we can check what are the different Generations like this):" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false + "nbformat_minor": 4, + "nbformat": 4, + "cells": [ + { + "cell_type": "markdown", + "source": "
\n

\n

\n

\nData visualization with Seaborn\n

\n
", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "## About seaborn\nSeaborn is a Python data visualization library based on matplotlib. It provides a high-level interface for drawing attractive and informative statistical graphics, which is very powerful for visualizing categorical data.\n\n![](https://d1rwhvwstyk9gu.cloudfront.net/2017/07/seaburn-1.png)\n\nBefore we get started, we need to install Seaborn. Run the cell below.", + "metadata": {} + }, + { + "cell_type": "code", + "source": "import piplite\nawait piplite.install('seaborn')", + "metadata": { + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "We will be using the dataset [Pokemon.csv](https://gist.github.com/armgilles/194bcff35001e7eb53a2a8b441e8b2c6). Let's have a look at the data:", + "metadata": {} + }, + { + "cell_type": "code", + "source": "import pandas as pd\n\npokemon_df = pd.read_csv('../data/Pokemon/pokemon.csv', index_col=0)\npokemon_df.head(10)", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "---\n\n

\nCategorical scatterplots\n


\n
", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "For example, we want to compare the Attack of different types of Pokemon, to see if any type is generally more powerful than the others:", + "metadata": {} + }, + { + "cell_type": "code", + "source": "import seaborn as sns\nimport matplotlib.pyplot as plt\n\nsns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df);", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "When import, we usually simplify 'seaborn' as 'sns'. (It's a [West Wing / Rob Lowe](https://en.wikipedia.org/wiki/Sam_Seaborn) reference!) Note that we have to also have to import `matplotlib.pyplot` because Seaborn is a library that sits on top of matplotlib. We got a plot but it looks ugly and not readable, let's add some configuration to make it nicer.", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "**Try: adding `aspect=2.5` as the last arguments in the following `sns.catplot`**", + "metadata": {} + }, + { + "cell_type": "code", + "source": "sns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df);", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "So you can see that by adding 'aspect' we make the plot wider. The width of the plot is equal to 'aspect * height' so by adding 'aspect' we increase the width of the plot. It is one of the configurations that we can add to the plot. For the whole list and their details, we can refer to the [official documentation](https://seaborn.pydata.org/generated/seaborn.catplot.html#seaborn.catplot) but we will give an introduction to a few common ones.", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "For example, here we see that there's a random x-axis offset for all the points so we can see them without dots overlapping each other. This is done by the 'jitter' setting which is default to True. Let's turn it off and see what it looks like:", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "**Try: adding `jitter=False` as the last arguments in the following `sns.catplot`**", + "metadata": {} + }, + { + "cell_type": "code", + "source": "sns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df, aspect=2.5);", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "So we now have a plot that points are align according to their catagories without the x-axis offsets. Which one to use is depending on if the population of the value (e.g. Attack) is important. In our case, we want to know how the Attack is distributed in each Type so many be it's good to have 'jitter' on, or even better if we can spread it out even more and show the distribution:", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "**Try: adding `kind=\"swarm\"` as the last arguments in the following `sns.catplot`**", + "metadata": {} + }, + { + "cell_type": "code", + "source": "sns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df, aspect=2.5);", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "Here we can do it by setting 'kind' to 'swarm' so the points are not overlapping. The disadvantage is that this ploy will need more space horizontally. Imagine we don't want to make the plot super wide due to the limitation of the paper. We can turn it 90 degrees by flipping the x and the y,also we would adjust the aspect and the height:", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "**Try: swap `x` and `y`, and add `height=12, aspect=0.6, kind=\"swarm\"` in the arguments of the following `sns.catplot`**", + "metadata": {} + }, + { + "cell_type": "code", + "source": "sns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df);", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "There are a few things we can observe so far:\n\n1. For some Types, like Psychic has a very large range of Attack with a long tail the end (i.e. some Physic Types has very high Attack power while most of the Psychic type does not).\n\n2. On the other hand, the Poison type are mostly in the range of 40-110 Attacks.\n\n3. In general Dragon Types have more Attack power than Fairy, but there are 2 Fairy type that has more attack power.", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "However, we would like to look deeper: I have a theory that Legendary Pokemon are more powerful. let's colour code according to 'Legendary' to see if the pokemon is Legendary or not will have something to do with the Attack of the pokemon:", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "**Try: adding `hue=\"Legendary\"` as the last arguments in the following `sns.catplot`**", + "metadata": {} + }, + { + "cell_type": "code", + "source": "plt.figure(figsize=(15, 6))\nsns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df, size=7)", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "Ah ha! We see that a lot of the Psychic Type that has higher that others in Attack is actually Legendary pokemon. That also happen to the Ground Type and the Flying type.", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "### Exercise\nNow it's your turn to do some analysis. Pick a property of the Pokemon: HP, Defense, Sp. Atk, Sp. Def or Speed and do the similar analysis as above to see if you can find any interesting facts about Pokemon.", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "---\n\n

\nBuilding structured multi-plot grids\n


\n
", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "Sometimes, we would have multiple plots in one graph for comparison. One way to do it in seaborn is to use FacetGrid. The FacetGrid class is useful when you want to visualize the distribution of a variable or the relationship between multiple variables separately within subsets of your dataset. In the following, we will be using FacetGrid to see if there is a difference for our analysis above across different Generations.", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "To make a FacetGrid, we can do the following:", + "metadata": {} + }, + { + "cell_type": "code", + "source": "g = sns.FacetGrid(pokemon_df, col=\"Generation\")", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "Look we have 6 plot areas which match as the number of different of Generations that we have\n(we can check what are the different Generations like this):", + "metadata": {} + }, + { + "cell_type": "code", + "source": "pokemon_df[\"Generation\"].unique()", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "However, we would like to have the plots align vertically rather than horizontally.", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "**Try: replace `col` with `row` in the following `sns.FacetGrid`**", + "metadata": {} + }, + { + "cell_type": "code", + "source": "g = sns.FacetGrid(pokemon_df, col=\"Generation\")", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "Ok, now we have the layout, how we gonna to put the plot in? For some plots, it could be done with the [FacetGrid.map()](https://seaborn.pydata.org/generated/seaborn.FacetGrid.map.html#seaborn.FacetGrid.map) method, for example, using sns.countplot to count how many Pokemon in different types:", + "metadata": {} + }, + { + "cell_type": "code", + "source": "g = sns.FacetGrid(pokemon_df, row=\"Generation\", aspect=3.5)\ng.map(sns.countplot, \"Type 1\");", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "But with sns.catplot that we used before, this are even simpler. As catplot is already a FacetGrid , we can directly add the `row` or `col` setting to it.", + "metadata": {} + }, + { + "cell_type": "markdown", + "source": "**Try: adding `row=\"Generation\"` as the last arguments in the following `sns.catplot`**", + "metadata": {} + }, + { + "cell_type": "code", + "source": "plt.figure(figsize=(15, 6))\nsns.catplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df, size=7, hue=\"Legendary\", aspect=2.5)", + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "collapsed": false, + "trusted": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": "Now you see that in each generation, the Legendary Pokemon are outliers with super attack powers comparing with the others within their own generation. For details using FacetGrids, you can see the official documentation here: https://seaborn.pydata.org/tutorial/axis_grids.html", + "metadata": {} } - }, - "outputs": [], - "source": [ - "pokemon_df[\"Generation\"].unique()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "However, we would like to have the plots align vertically rather than horizontally." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Try: replace `col` with `row` in the following `sns.FacetGrid`**" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "g = sns.FacetGrid(pokemon_df, col=\"Generation\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Ok, now we have the layout, how we gonna to put the plot in? For some plots, it could be done with the [FacetGrid.map()](https://seaborn.pydata.org/generated/seaborn.FacetGrid.map.html#seaborn.FacetGrid.map) method, for example, using sns.countplot to count how many Pokemon in different types:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "g = sns.FacetGrid(pokemon_df, row=\"Generation\", aspect=3.5)\n", - "g.map(sns.countplot, \"Type 1\");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "But with sns.catplot that we used before, this are even simpler. As catplot is already a FacetGrid , we can directly add the `row` or `col` setting to it." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Try: adding `row=\"Generation\"` as the last arguments in the following `sns.catplot`**" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "jupyter": { - "outputs_hidden": false - } - }, - "outputs": [], - "source": [ - "plt.figure(figsize=(15, 6))\n", - "sns.stripplot(x=\"Type 1\", y=\"Attack\", data=pokemon_df, size=7, hue=\"Legendary\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now you see that in each generation, the Legendary Pokemon are outliers with super attack powers comparing with the others within their own generation. For details using FacetGrids, you can see the official documentation here: https://seaborn.pydata.org/tutorial/axis_grids.html" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (system-wide)", - "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.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} + ] +} \ No newline at end of file diff --git a/content/notebooks/4. More Python basics.ipynb b/content/notebooks/4. More Python basics.ipynb index ec77f4f..5b79594 100644 --- a/content/notebooks/4. More Python basics.ipynb +++ b/content/notebooks/4. More Python basics.ipynb @@ -19,7 +19,7 @@ "source": [ "***Note***: This notebook contains solution cells with (a) solution. Remember there is not only one solution to a problem! \n", "You will recognise these cells as they start with **# %**. \n", - "If you would like to see the solution, you will have to remove the **#** (which can be done by using **Ctrl** and **?**) and run the cell. If you want to run the solution code, you will have to run the cell again." + "If you would like to see the solution, you will have to remove the **#** (which can also be done by using **Ctrl** and **?**) and run the cell. If you want to run the solution code, you will have to run the cell again." ] }, { @@ -81,7 +81,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/04_01.py" + "# %run ../solutions/04_01.py" ] }, { @@ -106,7 +106,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/04_02.py" + "# %run ../solutions/04_02.py" ] }, { @@ -130,7 +130,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/04_03.py" + " %run ../solutions/04_03.py" ] }, { @@ -244,7 +244,7 @@ "metadata": {}, "outputs": [], "source": [ - "name = input('What is your name? ')\n", + "name = ''\n", "\n", "if len(name) > 6:\n", " print('You have a long name.')\n", @@ -280,7 +280,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/04_04.py" + "# %run ../solutions/04_04.py" ] }, { @@ -411,7 +411,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - ">Get the documentation for the is_greeting function." + ">Get the documentation for the is_greeting function. Hint: Try using a question mark." ] }, { @@ -427,7 +427,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/04_05.py" + "# %run ../solutions/04_05.py" ] }, { @@ -452,13 +452,13 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/04_06.py" + "# %run ../solutions/04_06.py" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (system-wide)", + "display_name": "Python 3.10.5 64-bit", "language": "python", "name": "python3" }, @@ -472,7 +472,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.10.5" + }, + "vscode": { + "interpreter": { + "hash": "97cc609b13305c559618ec78a438abc56230b9381f827f22d070313b9a1f3777" + } } }, "nbformat": 4, diff --git a/content/notebooks/5. More Pandas.ipynb b/content/notebooks/5. More Pandas.ipynb index 6cd7e11..65f1edb 100644 --- a/content/notebooks/5. More Pandas.ipynb +++ b/content/notebooks/5. More Pandas.ipynb @@ -24,6 +24,28 @@ "If you would like to see the solution, you will have to remove the **#** (which can be done by using **Ctrl** and **?**) and run the cell. If you want to run the solution code, you will have to run the cell again." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, let's install the libraries we need for this notebook. Run the cell below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pyodide_js\n", + "\n", + "# Install Matplotlib\n", + "await pyodide_js.loadPackage(\"matplotlib\")\n", + "\n", + "# Install pandas\n", + "await pyodide_js.loadPackage(\"pandas\")" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -42,8 +64,7 @@ "source": [ "> 1. Import pandas (with the mostly used convention seen in notebook 2). \n", "> 2. Import datetime. \n", - "> 3. Import matplotlib (as shown in notebook 3.1). \n", - "> 4. Add the magic command to show the plot in Jupyter." + "> 3. Import matplotlib (as shown in notebook 3.1). " ] }, { @@ -67,9 +88,25 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_01.py" + "# %run ../solutions/05_01.py" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **BONUS EXERCISE**: Add the magic command to show the plot in Jupyter.\n", + "\n", + "HINT: try starting with a '%' sign." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -105,7 +142,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_02.py" + "# %run ../solutions/05_02.py" ] }, { @@ -136,7 +173,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_03.py" + "# %run ../solutions/05_03.py" ] }, { @@ -144,7 +181,7 @@ "metadata": {}, "source": [ "You can see that the header are not at the right place. \n", - "If you have a look at the documentation, you will see that the *header* parameter of the read_csv method is set to *infer*. It will infer the header using the first row (which has the index *0*)." + "If you have a look at the documentation, you will see that the *header* parameter of the `read_csv` method is set to *infer*. Hence, it will infer the header using the first row, which has the index *0*." ] }, { @@ -175,7 +212,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_04.py" + "# %run ../solutions/05_04.py" ] }, { @@ -206,7 +243,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_05.py" + "# %run ../solutions/05_05.py" ] }, { @@ -237,7 +274,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_06.py" + "# %run ../solutions/05_06.py" ] }, { @@ -287,7 +324,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_07.py" + "# %run ../solutions/05_07.py" ] }, { @@ -318,7 +355,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_08.py" + "# %run ../solutions/05_08.py" ] }, { @@ -349,7 +386,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_09.py" + "# %run ../solutions/05_09.py" ] }, { @@ -382,7 +419,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_10.py" + "# %run ../solutions/05_10.py" ] }, { @@ -425,7 +462,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_11.py" + "# %run ../solutions/05_11.py" ] }, { @@ -464,7 +501,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_12.py" + "# %run ../solutions/05_12.py" ] }, { @@ -505,7 +542,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_13.py" + "# %run ../solutions/05_13.py" ] }, { @@ -563,7 +600,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_14.py" + "# %run ../solutions/05_14.py" ] }, { @@ -596,7 +633,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_15.py" + "# %run ../solutions/05_15.py" ] }, { @@ -629,7 +666,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_16.py" + "# %run ../solutions/05_16.py" ] }, { @@ -660,7 +697,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_17.py" + "# %run ../solutions/05_17.py" ] }, { @@ -691,7 +728,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_18.py" + "# %run ../solutions/05_18.py" ] }, { @@ -735,7 +772,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_19.py" + "# %run ../solutions/05_19.py" ] }, { @@ -766,7 +803,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_20.py" + "# %run ../solutions/05_20.py" ] }, { @@ -798,7 +835,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_21.py" + "# %run ../solutions/05_21.py" ] }, { @@ -829,7 +866,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_22.py" + "# %run ../solutions/05_22.py" ] }, { @@ -861,7 +898,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_23.py" + "# %run ../solutions/05_23.py" ] }, { @@ -892,7 +929,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_24.py" + "# %run ../solutions/05_24.py" ] }, { @@ -923,7 +960,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_25.py" + "# %run ../solutions/05_25.py" ] }, { @@ -949,7 +986,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/05_26.py" + "# %run ../solutions/05_26.py" ] }, { @@ -1012,7 +1049,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_27.py" + "# %run ../solutions/05_27.py" ] }, { @@ -1041,9 +1078,7 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "df['city'].value_counts()" - ] + "source": [] }, { "cell_type": "code", @@ -1051,7 +1086,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/05_28.py" + "# %run ../solutions/05_28.py" ] }, { @@ -1078,7 +1113,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/05_29.py" + "# %run ../solutions/05_29.py" ] }, { @@ -1119,7 +1154,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/05_30.py" + "# %run ../solutions/05_30.py" ] }, { @@ -1143,7 +1178,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/05_31.py" + "# %run ../solutions/05_31.py" ] }, { @@ -1166,7 +1201,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/05_32.py" + "# %run ../solutions/05_32.py" ] }, { @@ -1189,7 +1224,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/05_33.py" + "# %run ../solutions/05_33.py" ] }, { @@ -1239,7 +1274,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_34.py" + "# %run ../solutions/05_34.py" ] }, { @@ -1270,7 +1305,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_35.py" + "# %run ../solutions/05_35.py" ] }, { @@ -1305,7 +1340,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/05_36.py" + "# %run ../solutions/05_36.py" ] }, { @@ -1338,7 +1373,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/05_37.py" + "# %run ../solutions/05_37.py" ] }, { @@ -1361,7 +1396,7 @@ "metadata": {}, "outputs": [], "source": [ - "# %load ../solutions/05_38.py" + "# %run ../solutions/05_38.py" ] }, { @@ -1404,7 +1439,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_39.py" + "# %run ../solutions/05_39.py" ] }, { @@ -1436,7 +1471,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_40.py" + "# %run ../solutions/05_40.py" ] }, { @@ -1469,7 +1504,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_41.py" + "# %run ../solutions/05_41.py" ] }, { @@ -1500,7 +1535,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_42.py" + "# %run ../solutions/05_42.py" ] }, { @@ -1532,7 +1567,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_43.py" + "# %run ../solutions/05_43.py" ] }, { @@ -1575,7 +1610,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_44.py" + "# %run ../solutions/05_44.py" ] }, { @@ -1606,7 +1641,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_45.py" + "# %run ../solutions/05_45.py" ] }, { @@ -1656,7 +1691,7 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_46.py" + "# %run ../solutions/05_46.py" ] }, { @@ -1687,13 +1722,13 @@ }, "outputs": [], "source": [ - "# %load ../solutions/05_47.py" + "# %run ../solutions/05_47.py" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (system-wide)", + "display_name": "Python 3.10.5 64-bit", "language": "python", "name": "python3" }, @@ -1707,7 +1742,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.10.5" + }, + "vscode": { + "interpreter": { + "hash": "97cc609b13305c559618ec78a438abc56230b9381f827f22d070313b9a1f3777" + } } }, "nbformat": 4, diff --git a/content/solutions/01_03.py b/content/solutions/01_03.py index 18a1322..92d4af6 100644 --- a/content/solutions/01_03.py +++ b/content/solutions/01_03.py @@ -1 +1 @@ -"I'm enjoying this workshop!" \ No newline at end of file +print("I'm enjoying this workshop!") \ No newline at end of file diff --git a/content/solutions/01_05.py b/content/solutions/01_05.py index 5c81d54..4f8359b 100644 --- a/content/solutions/01_05.py +++ b/content/solutions/01_05.py @@ -1 +1 @@ -'I\'m enjoying this workshop!' \ No newline at end of file +print('I\'m enjoying this workshop!') \ No newline at end of file diff --git a/content/solutions/01_06.py b/content/solutions/01_06.py index ab3be34..e75ba31 100644 --- a/content/solutions/01_06.py +++ b/content/solutions/01_06.py @@ -1 +1,2 @@ -s[-1] \ No newline at end of file +s = 'I am a Pythonista.' +print(s[-1]) \ No newline at end of file diff --git a/content/solutions/01_07.py b/content/solutions/01_07.py index 428c4d6..a2f6622 100644 --- a/content/solutions/01_07.py +++ b/content/solutions/01_07.py @@ -1 +1,2 @@ -s[-3:] \ No newline at end of file +s = "I am a Pythonista." +print(s[-3:]) \ No newline at end of file diff --git a/content/solutions/01_08.py b/content/solutions/01_08.py index 929aaca..617a7b0 100644 --- a/content/solutions/01_08.py +++ b/content/solutions/01_08.py @@ -1 +1,2 @@ -"I" not in s \ No newline at end of file +s = "I am a Pythonista." +print("I" not in s) \ No newline at end of file diff --git a/content/solutions/01_09.py b/content/solutions/01_09.py index 5b947f9..1d058a2 100644 --- a/content/solutions/01_09.py +++ b/content/solutions/01_09.py @@ -1 +1 @@ -3 + 4 \ No newline at end of file +print(3 + 4) \ No newline at end of file diff --git a/content/solutions/01_10.py b/content/solutions/01_10.py index 992d1cf..508534c 100644 --- a/content/solutions/01_10.py +++ b/content/solutions/01_10.py @@ -1 +1 @@ -10.0 - 6 \ No newline at end of file +print(10.0 - 6) \ No newline at end of file diff --git a/content/solutions/01_11.py b/content/solutions/01_11.py index 9f650f4..528d11d 100644 --- a/content/solutions/01_11.py +++ b/content/solutions/01_11.py @@ -1 +1 @@ -15 * 12 \ No newline at end of file +print(15 * 12) \ No newline at end of file diff --git a/content/solutions/01_12.py b/content/solutions/01_12.py index b4db663..f519641 100644 --- a/content/solutions/01_12.py +++ b/content/solutions/01_12.py @@ -1 +1 @@ -2**6 \ No newline at end of file +print(2**6) \ No newline at end of file diff --git a/content/solutions/01_13.py b/content/solutions/01_13.py index 74eeeaf..e7680ca 100644 --- a/content/solutions/01_13.py +++ b/content/solutions/01_13.py @@ -1 +1 @@ -3.1**2 \ No newline at end of file +print(3.1**2) \ No newline at end of file diff --git a/content/solutions/01_14.py b/content/solutions/01_14.py index 7f0af36..5c8c371 100644 --- a/content/solutions/01_14.py +++ b/content/solutions/01_14.py @@ -1 +1 @@ -5.0**2 \ No newline at end of file +print(5.0**2) \ No newline at end of file diff --git a/content/solutions/01_15.py b/content/solutions/01_15.py index 512522a..dd31e59 100644 --- a/content/solutions/01_15.py +++ b/content/solutions/01_15.py @@ -1 +1 @@ -6 / 2 \ No newline at end of file +print(6 / 2) \ No newline at end of file diff --git a/content/solutions/01_16.py b/content/solutions/01_16.py index d5e993a..976426b 100644 --- a/content/solutions/01_16.py +++ b/content/solutions/01_16.py @@ -1 +1 @@ -6 // 2 \ No newline at end of file +print(6 // 2) \ No newline at end of file diff --git a/content/solutions/01_17.py b/content/solutions/01_17.py index 32cddde..b3bda13 100644 --- a/content/solutions/01_17.py +++ b/content/solutions/01_17.py @@ -1 +1 @@ -19 / 5 \ No newline at end of file +print(19 / 5) \ No newline at end of file diff --git a/content/solutions/01_18.py b/content/solutions/01_18.py index 9f5b26b..b15f815 100644 --- a/content/solutions/01_18.py +++ b/content/solutions/01_18.py @@ -1 +1 @@ -19 // 5 \ No newline at end of file +print(19 // 5) \ No newline at end of file diff --git a/content/solutions/01_19.py b/content/solutions/01_19.py index 275fd5a..fe18c51 100644 --- a/content/solutions/01_19.py +++ b/content/solutions/01_19.py @@ -1 +1 @@ -19 % 5 \ No newline at end of file +print(19 % 5) \ No newline at end of file diff --git a/content/solutions/01_20.py b/content/solutions/01_20.py index 086bcd1..6485aa8 100644 --- a/content/solutions/01_20.py +++ b/content/solutions/01_20.py @@ -1 +1 @@ -False != 2 \ No newline at end of file +print(False != 2) \ No newline at end of file diff --git a/content/solutions/01_21.py b/content/solutions/01_21.py index a9a3622..991d23f 100644 --- a/content/solutions/01_21.py +++ b/content/solutions/01_21.py @@ -1 +1,2 @@ -len("Sandrine") > 8 \ No newline at end of file +name = "Sandrine" +print(f"Is {name} more than 8 characters? {len(name) > 8}") \ No newline at end of file diff --git a/content/solutions/01_22.py b/content/solutions/01_22.py index c339d50..8b6331f 100644 --- a/content/solutions/01_22.py +++ b/content/solutions/01_22.py @@ -1 +1,4 @@ -(len("Sandrine") > 5) and (len("Cheuk") < 7) \ No newline at end of file +name_1 = "Sandrine" +name_2 = "Cheuk" + +print(f"Is {name_1} > 5 and {name_2} < 7 characters? {(len(name_1) > 5) and (len(name_2) < 7)}") \ No newline at end of file diff --git a/content/solutions/01_23.py b/content/solutions/01_23.py index ad36c1c..12a449b 100644 --- a/content/solutions/01_23.py +++ b/content/solutions/01_23.py @@ -1 +1,2 @@ -list_greeting[0] \ No newline at end of file +list_greeting = ['Hallo', 'Bonjour', 10, 'Hello', 'Ciao', False] +print(list_greeting[0]) \ No newline at end of file diff --git a/content/solutions/01_24.py b/content/solutions/01_24.py index 4aaa6d2..e87aa97 100644 --- a/content/solutions/01_24.py +++ b/content/solutions/01_24.py @@ -1 +1,2 @@ -list_greeting[3:] \ No newline at end of file +list_greeting = ['Hallo', 'Bonjour', 10, 'Hello', 'Ciao', False] +print(list_greeting[3:]) \ No newline at end of file diff --git a/content/solutions/01_25.py b/content/solutions/01_25.py index 2d29224..0958419 100644 --- a/content/solutions/01_25.py +++ b/content/solutions/01_25.py @@ -1 +1,2 @@ -list_greeting[:4] \ No newline at end of file +list_greeting = ['Hallo', 'Bonjour', 10, 'Hello', 'Ciao', False] +print(list_greeting[:4]) \ No newline at end of file diff --git a/content/solutions/01_26.py b/content/solutions/01_26.py index c8b200c..c942f85 100644 --- a/content/solutions/01_26.py +++ b/content/solutions/01_26.py @@ -1 +1,2 @@ -list_greeting[::2] \ No newline at end of file +list_greeting = ['Hallo', 'Bonjour', 10, 'Hello', 'Ciao', False] +print(list_greeting[::2]) \ No newline at end of file diff --git a/content/solutions/01_27.py b/content/solutions/01_27.py index eb29a58..66bede0 100644 --- a/content/solutions/01_27.py +++ b/content/solutions/01_27.py @@ -1,2 +1,4 @@ -list_greeting[2] = "Ola" +list_greeting = ['Hallo', 'Bonjour', 10, 'Hello', 'Ciao', False] +list_greeting[-1] = 'Ave' +list_greeting[2] = "Hola" print(list_greeting) \ No newline at end of file diff --git a/content/solutions/01_28.py b/content/solutions/01_28.py index d7f6573..726122a 100644 --- a/content/solutions/01_28.py +++ b/content/solutions/01_28.py @@ -1 +1,2 @@ -10 in list_greeting \ No newline at end of file +list_greeting = ['Hallo', 'Bonjour', 'Hola', 'Hello', 'Ciao', 'Ave'] +print(10 in list_greeting) \ No newline at end of file diff --git a/content/solutions/01_29.py b/content/solutions/01_29.py index a42b108..6952d6f 100644 --- a/content/solutions/01_29.py +++ b/content/solutions/01_29.py @@ -1 +1,2 @@ -"Ole" not in list_greeting \ No newline at end of file +list_greeting = ['Hallo', 'Bonjour', 'Hola', 'Hello', 'Ciao', 'Ave'] +print("Ole" not in list_greeting) \ No newline at end of file diff --git a/content/solutions/01_31.py b/content/solutions/01_31.py index 1f8c4e5..ddc0a86 100644 --- a/content/solutions/01_31.py +++ b/content/solutions/01_31.py @@ -1 +1,2 @@ -len(snakes) \ No newline at end of file +snakes = "🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍" +print(len(snakes)) \ No newline at end of file diff --git a/content/solutions/01_32.py b/content/solutions/01_32.py index 9cf9ec1..a333e1e 100644 --- a/content/solutions/01_32.py +++ b/content/solutions/01_32.py @@ -1 +1,2 @@ -len(list_greeting) \ No newline at end of file +list_greeting = ['Hallo', 'Bonjour', 'Hola', 'Hello', 'Ciao', 'Ave'] +print(len(list_greeting)) \ No newline at end of file diff --git a/content/solutions/01_33.py b/content/solutions/01_33.py index 089fab2..9b25407 100644 --- a/content/solutions/01_33.py +++ b/content/solutions/01_33.py @@ -1 +1 @@ -max(1, 2, 3, 4, 5) \ No newline at end of file +print(max(1, 2, 3, 4, 5)) \ No newline at end of file diff --git a/content/solutions/01_34.py b/content/solutions/01_34.py index 1e307e4..5b2c7d8 100644 --- a/content/solutions/01_34.py +++ b/content/solutions/01_34.py @@ -1 +1 @@ -round(123.45) \ No newline at end of file +print(round(123.45)) \ No newline at end of file diff --git a/content/solutions/01_35.py b/content/solutions/01_35.py index bfcdf9d..a5ba06c 100644 --- a/content/solutions/01_35.py +++ b/content/solutions/01_35.py @@ -1 +1 @@ -round(123.45, 1) \ No newline at end of file +print(round(123.45, 1)) \ No newline at end of file diff --git a/content/solutions/01_36.py b/content/solutions/01_36.py index a4c7c36..e293d6d 100644 --- a/content/solutions/01_36.py +++ b/content/solutions/01_36.py @@ -1 +1,3 @@ -list_greeting.append("Aloha") \ No newline at end of file +list_greeting = ['Hallo', 'Bonjour', 'Hola', 'Hello', 'Ciao', 'Ave'] +list_greeting.append("Aloha") +print(list_greeting) \ No newline at end of file diff --git a/content/solutions/01_37.py b/content/solutions/01_37.py index 03c927c..776a811 100644 --- a/content/solutions/01_37.py +++ b/content/solutions/01_37.py @@ -1,3 +1,3 @@ from math import sqrt -sqrt(24336) \ No newline at end of file +print(sqrt(24336)) \ No newline at end of file diff --git a/content/solutions/01_38.py b/content/solutions/01_38.py index 19e2957..75aa57d 100644 --- a/content/solutions/01_38.py +++ b/content/solutions/01_38.py @@ -1,3 +1,5 @@ +#await micropip.install("numpy") + import numpy as np -np.sin(np.pi / 4) \ No newline at end of file +print(np.sin(np.pi / 4)) \ No newline at end of file diff --git a/content/solutions/02_02.py b/content/solutions/02_02.py index 06a5823..1946ebd 100644 --- a/content/solutions/02_02.py +++ b/content/solutions/02_02.py @@ -1 +1,5 @@ -df = pd.read_csv("../data/Penguins/penguins.csv") \ No newline at end of file +import pandas as pd +from IPython.display import display + +df = pd.read_csv("../data/Penguins/penguins.csv") +display(df) \ No newline at end of file diff --git a/content/solutions/02_03.py b/content/solutions/02_03.py index dca017b..50f8669 100644 --- a/content/solutions/02_03.py +++ b/content/solutions/02_03.py @@ -1 +1,5 @@ -df.tail(3) \ No newline at end of file +import pandas as pd +from IPython.display import display +df = pd.read_csv("../data/Penguins/penguins.csv") + +display(df.tail(3)) \ No newline at end of file diff --git a/content/solutions/02_04.py b/content/solutions/02_04.py index 20bfa30..21179e4 100644 --- a/content/solutions/02_04.py +++ b/content/solutions/02_04.py @@ -1 +1,4 @@ -df.shape \ No newline at end of file +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") + +print(df.shape) \ No newline at end of file diff --git a/content/solutions/02_05.py b/content/solutions/02_05.py index e1ed112..ad2647e 100644 --- a/content/solutions/02_05.py +++ b/content/solutions/02_05.py @@ -1 +1,4 @@ -df.info() \ No newline at end of file +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") + +print(df.info()) \ No newline at end of file diff --git a/content/solutions/02_06.py b/content/solutions/02_06.py index 4cc9080..eba4e66 100644 --- a/content/solutions/02_06.py +++ b/content/solutions/02_06.py @@ -1 +1,4 @@ -df.columns \ No newline at end of file +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") + +print(df.columns) \ No newline at end of file diff --git a/content/solutions/02_07.py b/content/solutions/02_07.py index 2e52ab3..aef01b2 100644 --- a/content/solutions/02_07.py +++ b/content/solutions/02_07.py @@ -1 +1,3 @@ -pd.options.display.max_rows = 25 \ No newline at end of file +import pandas as pd + +pd.set_option('display.max_rows', 25) \ No newline at end of file diff --git a/content/solutions/02_08.py b/content/solutions/02_08.py index 9b1475e..575915e 100644 --- a/content/solutions/02_08.py +++ b/content/solutions/02_08.py @@ -1 +1,5 @@ -df["bill_length_mm"] \ No newline at end of file +import pandas as pd +from IPython.display import display +df = pd.read_csv("../data/Penguins/penguins.csv") + +display(df["bill_length_mm"]) \ No newline at end of file diff --git a/content/solutions/02_09.py b/content/solutions/02_09.py index b5e231a..b379909 100644 --- a/content/solutions/02_09.py +++ b/content/solutions/02_09.py @@ -1 +1,5 @@ -df.iloc[11] \ No newline at end of file +import pandas as pd +from IPython.display import display +df = pd.read_csv("../data/Penguins/penguins.csv") + +display(df.iloc[11]) \ No newline at end of file diff --git a/content/solutions/02_10.py b/content/solutions/02_10.py index 757e138..5bcd203 100644 --- a/content/solutions/02_10.py +++ b/content/solutions/02_10.py @@ -1 +1,5 @@ -df.loc[11] \ No newline at end of file +import pandas as pd +from IPython.display import display +df = pd.read_csv("../data/Penguins/penguins.csv") + +display(df.loc[11]) \ No newline at end of file diff --git a/content/solutions/02_11.py b/content/solutions/02_11.py index 5f6d037..138e910 100644 --- a/content/solutions/02_11.py +++ b/content/solutions/02_11.py @@ -1 +1,5 @@ -df.iloc[-3:, 2] \ No newline at end of file +import pandas as pd +from IPython.display import display +df = pd.read_csv("../data/Penguins/penguins.csv") + +display(df.iloc[-3:, 2]) \ No newline at end of file diff --git a/content/solutions/02_12.py b/content/solutions/02_12.py index ccd1060..78fd717 100644 --- a/content/solutions/02_12.py +++ b/content/solutions/02_12.py @@ -1 +1,5 @@ -df.loc[341:, "bill_length_mm"] \ No newline at end of file +import pandas as pd +from IPython.display import display +df = pd.read_csv("../data/Penguins/penguins.csv") + +display(df.loc[341:, "bill_length_mm"]) \ No newline at end of file diff --git a/content/solutions/02_13.py b/content/solutions/02_13.py index f20bfb2..6d3eaf1 100644 --- a/content/solutions/02_13.py +++ b/content/solutions/02_13.py @@ -1 +1,5 @@ -df.iloc[[145, 7, 0], [4, -2]] \ No newline at end of file +import pandas as pd +from IPython.display import display +df = pd.read_csv("../data/Penguins/penguins.csv") + +display(df.iloc[[145, 7, 0], [4, -2]]) \ No newline at end of file diff --git a/content/solutions/02_14.py b/content/solutions/02_14.py index b46a9a6..b93e285 100644 --- a/content/solutions/02_14.py +++ b/content/solutions/02_14.py @@ -1 +1,5 @@ -df.loc[[145, 7, 0], ["flipper_length_mm", "body_mass_g"]] \ No newline at end of file +import pandas as pd +from IPython.display import display +df = pd.read_csv("../data/Penguins/penguins.csv") + +display(df.loc[[145, 7, 0], ["flipper_length_mm", "body_mass_g"]]) \ No newline at end of file diff --git a/content/solutions/02_15.py b/content/solutions/02_15.py index 8540a2a..b58d4a7 100644 --- a/content/solutions/02_15.py +++ b/content/solutions/02_15.py @@ -1,2 +1,6 @@ +import pandas as pd +from IPython.display import display +df = pd.read_csv("../data/Penguins/penguins.csv") + mask_PW_PL = (df["body_mass_g"] > 4000) & (df["flipper_length_mm"] < 185) -df[mask_PW_PL] \ No newline at end of file +display(df[mask_PW_PL]) \ No newline at end of file diff --git a/content/solutions/02_16.py b/content/solutions/02_16.py index bfbdc0d..ef32cd5 100644 --- a/content/solutions/02_16.py +++ b/content/solutions/02_16.py @@ -1 +1,4 @@ -df["species"].unique() \ No newline at end of file +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") + +print(df["species"].unique()) \ No newline at end of file diff --git a/content/solutions/02_17.py b/content/solutions/02_17.py index 0ab5391..4caf8c1 100644 --- a/content/solutions/02_17.py +++ b/content/solutions/02_17.py @@ -1 +1,4 @@ -df["flipper_length_mm"].isnull().sum() \ No newline at end of file +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") + +print(df["flipper_length_mm"].isnull().sum()) \ No newline at end of file diff --git a/content/solutions/02_18.py b/content/solutions/02_18.py index 84339d0..f92629e 100644 --- a/content/solutions/02_18.py +++ b/content/solutions/02_18.py @@ -1 +1,4 @@ -df["sex"].value_counts(dropna=False) \ No newline at end of file +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") + +print(df["sex"].value_counts(dropna=False)) \ No newline at end of file diff --git a/content/solutions/02_19.py b/content/solutions/02_19.py index 8697011..194966a 100644 --- a/content/solutions/02_19.py +++ b/content/solutions/02_19.py @@ -1 +1,4 @@ -df["species"].value_counts(normalize=True) \ No newline at end of file +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") + +print(df["species"].value_counts(normalize=True)) \ No newline at end of file diff --git a/content/solutions/02_20.py b/content/solutions/02_20.py index 9a0f24b..eb1281a 100644 --- a/content/solutions/02_20.py +++ b/content/solutions/02_20.py @@ -1 +1,4 @@ -df[df["flipper_length_mm"].isnull()].index \ No newline at end of file +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") + +print(df[df["flipper_length_mm"].isnull()].index) \ No newline at end of file diff --git a/content/solutions/02_21.py b/content/solutions/02_21.py index a9b1273..f4c1bc4 100644 --- a/content/solutions/02_21.py +++ b/content/solutions/02_21.py @@ -1 +1,3 @@ -?pd.DataFrame.dropna \ No newline at end of file +import pandas as pd + +print(pd.DataFrame.dropna.__doc__) \ No newline at end of file diff --git a/content/solutions/02_22.py b/content/solutions/02_22.py index 89cb40c..4703c72 100644 --- a/content/solutions/02_22.py +++ b/content/solutions/02_22.py @@ -1 +1,4 @@ +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") + df_2 = df.dropna(how="all") \ No newline at end of file diff --git a/content/solutions/02_23.py b/content/solutions/02_23.py index da2f480..009c745 100644 --- a/content/solutions/02_23.py +++ b/content/solutions/02_23.py @@ -1 +1,5 @@ +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") +df_2 = df.dropna(how="all") + print(f"number of rows of df_2: {df_2.shape[0]}") \ No newline at end of file diff --git a/content/solutions/02_24.py b/content/solutions/02_24.py index 9d41559..c3a5fe7 100644 --- a/content/solutions/02_24.py +++ b/content/solutions/02_24.py @@ -1 +1,5 @@ +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") +df_2 = df.dropna(how="all") + df_3 = df_2.dropna(how="any") \ No newline at end of file diff --git a/content/solutions/02_25.py b/content/solutions/02_25.py index 3deb842..8c80114 100644 --- a/content/solutions/02_25.py +++ b/content/solutions/02_25.py @@ -1 +1,6 @@ +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") +df_2 = df.dropna(how="all") +df_3 = df_2.dropna(how="any") + print(f"number of rows of df_3: {df_3.shape[0]}") \ No newline at end of file diff --git a/content/solutions/02_26.py b/content/solutions/02_26.py index 8b0e889..ea80adf 100644 --- a/content/solutions/02_26.py +++ b/content/solutions/02_26.py @@ -1 +1,6 @@ +import pandas as pd +df = pd.read_csv("../data/Penguins/penguins.csv") +df_2 = df.dropna(how="all") +df_3 = df_2.dropna(how="any") + df_4 = df_3.drop_duplicates() \ No newline at end of file diff --git a/content/solutions/02_27.py b/content/solutions/02_27.py index da1df3b..4c60b12 100644 --- a/content/solutions/02_27.py +++ b/content/solutions/02_27.py @@ -1 +1,8 @@ -df_4.describe() \ No newline at end of file +import pandas as pd +from IPython.display import display +df = pd.read_csv("../data/Penguins/penguins.csv") +df_2 = df.dropna(how="all") +df_3 = df_2.dropna(how="any") +df_4 = df_3.drop_duplicates() + +display(df_4.describe()) \ No newline at end of file diff --git a/content/solutions/02_28.py b/content/solutions/02_28.py index aa9d760..d90cc69 100644 --- a/content/solutions/02_28.py +++ b/content/solutions/02_28.py @@ -1 +1,11 @@ -df_4.dtypes \ No newline at end of file +import pandas as pd +from IPython.display import display +pd.options.mode.chained_assignment = None + +df = pd.read_csv("../data/Penguins/penguins.csv") +df_2 = df.dropna(how="all") +df_3 = df_2.dropna(how="any") +df_4 = df_3.drop_duplicates() +df_4['species'] = df_4['species'].astype('category') + +display(df_4.dtypes) \ No newline at end of file diff --git a/content/solutions/02_29.py b/content/solutions/02_29.py index ee30853..64b19d6 100644 --- a/content/solutions/02_29.py +++ b/content/solutions/02_29.py @@ -1 +1,10 @@ -df_4.min() \ No newline at end of file +import pandas as pd +pd.options.mode.chained_assignment = None + +df = pd.read_csv("../data/Penguins/penguins.csv") +df_2 = df.dropna(how="all") +df_3 = df_2.dropna(how="any") +df_4 = df_3.drop_duplicates() +df_4['species'] = df_4['species'].astype('category') + +print(df_4.min(numeric_only=True)) \ No newline at end of file diff --git a/content/solutions/02_30.py b/content/solutions/02_30.py index 03e20a5..846deee 100644 --- a/content/solutions/02_30.py +++ b/content/solutions/02_30.py @@ -1 +1,10 @@ -df_4["flipper_length_mm"].max() \ No newline at end of file +import pandas as pd +pd.options.mode.chained_assignment = None + +df = pd.read_csv("../data/Penguins/penguins.csv") +df_2 = df.dropna(how="all") +df_3 = df_2.dropna(how="any") +df_4 = df_3.drop_duplicates() +df_4['species'] = df_4['species'].astype('category') + +print(df_4["flipper_length_mm"].max()) \ No newline at end of file diff --git a/content/solutions/02_31.py b/content/solutions/02_31.py index 9cec756..6d03644 100644 --- a/content/solutions/02_31.py +++ b/content/solutions/02_31.py @@ -1 +1,11 @@ -df_4.groupby("species").median() \ No newline at end of file +import pandas as pd +from IPython.display import display +pd.options.mode.chained_assignment = None + +df = pd.read_csv("../data/Penguins/penguins.csv") +df_2 = df.dropna(how="all") +df_3 = df_2.dropna(how="any") +df_4 = df_3.drop_duplicates() +df_4['species'] = df_4['species'].astype('category') + +display(df_4.groupby("species").median(numeric_only=True)) \ No newline at end of file diff --git a/content/solutions/02_32.py b/content/solutions/02_32.py index 853bcf7..0378a45 100644 --- a/content/solutions/02_32.py +++ b/content/solutions/02_32.py @@ -1 +1,10 @@ +import pandas as pd +pd.options.mode.chained_assignment = None + +df = pd.read_csv("../data/Penguins/penguins.csv") +df_2 = df.dropna(how="all") +df_3 = df_2.dropna(how="any") +df_4 = df_3.drop_duplicates() +df_4['species'] = df_4['species'].astype('category') + df_4.to_csv("../data/Penguins/my_penguins.csv") \ No newline at end of file diff --git a/content/solutions/04_01.py b/content/solutions/04_01.py index ab320c4..382824a 100644 --- a/content/solutions/04_01.py +++ b/content/solutions/04_01.py @@ -1 +1,3 @@ -dict_greeting["Italy"] \ No newline at end of file +dict_greeting = {'Namibia':'Hallo', 'France':'Bonjour', 'Spain':'Ola', 'UK':'Hello', 'Italy':'Ciao'} + +print(dict_greeting["Italy"]) \ No newline at end of file diff --git a/content/solutions/04_02.py b/content/solutions/04_02.py index 14c5ddc..6536506 100644 --- a/content/solutions/04_02.py +++ b/content/solutions/04_02.py @@ -1,2 +1,4 @@ +dict_greeting = {'Namibia':'Hallo', 'France':'Bonjour', 'Spain':'Ola', 'UK':'Hello', 'Italy':'Ciao'} + dict_greeting["UK"] = "Good Morning" print(dict_greeting) \ No newline at end of file diff --git a/content/solutions/04_03.py b/content/solutions/04_03.py index fb2851f..f0e839f 100644 --- a/content/solutions/04_03.py +++ b/content/solutions/04_03.py @@ -1,2 +1,4 @@ +dict_greeting = {'Namibia':'Hallo', 'France':'Bonjour', 'Spain':'Ola', 'UK':'Hello', 'Italy':'Ciao'} + dict_greeting["Hawaii"] = "Aloha" print(dict_greeting) \ No newline at end of file diff --git a/content/solutions/04_05.py b/content/solutions/04_05.py index 371268b..66e5a12 100644 --- a/content/solutions/04_05.py +++ b/content/solutions/04_05.py @@ -1 +1,11 @@ -?is_greeting \ No newline at end of file +list_greeting = ['Hallo', 'Bonjour', 'Ola', 'Hello', 'Ciao', 'Ave'] + +def is_greeting(s): + """Returns True if s is in list_greeting, else False.""" + if s in list_greeting: + return True + else: + return False + + +help(is_greeting) \ No newline at end of file diff --git a/content/solutions/04_06.py b/content/solutions/04_06.py index 7e694ea..9519c1a 100644 --- a/content/solutions/04_06.py +++ b/content/solutions/04_06.py @@ -7,4 +7,11 @@ def f(x): """Returns the argument multiplied by 3 and increased by 10.""" - return (x * 3) + 10 \ No newline at end of file + return (x * 3) + 10 + + +print('def f(x):') +print('\t"""Returns the argument multiplied by 3 and increased by 10."""') +print('\treturn (x * 3) + 10\n') + +print('f(x) = ', f(4)) # x = 4 is arbitrary. Try with other values. \ No newline at end of file diff --git a/content/solutions/04_07.py b/content/solutions/04_07.py deleted file mode 100644 index e69de29..0000000 diff --git a/content/solutions/04_08.py b/content/solutions/04_08.py deleted file mode 100644 index e69de29..0000000 diff --git a/content/solutions/04_09.py b/content/solutions/04_09.py deleted file mode 100644 index e69de29..0000000 diff --git a/content/solutions/05_01.py b/content/solutions/05_01.py index 87e5a62..eb19a21 100644 --- a/content/solutions/05_01.py +++ b/content/solutions/05_01.py @@ -1,6 +1,11 @@ +#import libraries to run notebook import datetime - import matplotlib.pyplot as plt import pandas as pd -%matplotlib inline \ No newline at end of file +print('import datetime') +print('import matplotlib.pyplot as plt') +print('import pandas as pd') + +# solution for the bonus exercise +# %matplotlib inline \ No newline at end of file diff --git a/content/solutions/05_02.py b/content/solutions/05_02.py index b9dcabb..b709281 100644 --- a/content/solutions/05_02.py +++ b/content/solutions/05_02.py @@ -1 +1,4 @@ -df_2014 = pd.read_csv("../data/food_training/training_2014.csv") \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv") +print('df_2014 = pd.read_csv("../data/food_training/training_2014.csv")') \ No newline at end of file diff --git a/content/solutions/05_03.py b/content/solutions/05_03.py index a65ecc1..79b7a68 100644 --- a/content/solutions/05_03.py +++ b/content/solutions/05_03.py @@ -1 +1,5 @@ -df_2014.head() \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv") + +display(df_2014.head()) \ No newline at end of file diff --git a/content/solutions/05_04.py b/content/solutions/05_04.py index a6cf222..b5dbdee 100644 --- a/content/solutions/05_04.py +++ b/content/solutions/05_04.py @@ -1 +1,5 @@ -df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) + +print('df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1)') \ No newline at end of file diff --git a/content/solutions/05_05.py b/content/solutions/05_05.py index a65ecc1..cfee109 100644 --- a/content/solutions/05_05.py +++ b/content/solutions/05_05.py @@ -1 +1,5 @@ -df_2014.head() \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) + +display(df_2014.head()) \ No newline at end of file diff --git a/content/solutions/05_06.py b/content/solutions/05_06.py index 09a0c32..76d6ff4 100644 --- a/content/solutions/05_06.py +++ b/content/solutions/05_06.py @@ -1,2 +1,7 @@ +import pandas as pd + df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) -df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) \ No newline at end of file +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +print('df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1)') +print('df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1)') diff --git a/content/solutions/05_07.py b/content/solutions/05_07.py index ea505e8..05ace2c 100644 --- a/content/solutions/05_07.py +++ b/content/solutions/05_07.py @@ -1,2 +1,12 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + frames = [df_2014, df_2015, df_2016] -df = pd.concat(frames) \ No newline at end of file +df = pd.concat(frames) +# display(df) + +print('frames = [df_2014, df_2015, df_2016]') +print('df = pd.concat(frames)') \ No newline at end of file diff --git a/content/solutions/05_08.py b/content/solutions/05_08.py index 20bfa30..a97956d 100644 --- a/content/solutions/05_08.py +++ b/content/solutions/05_08.py @@ -1 +1,11 @@ -df.shape \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +print('df.shape') +display(df.shape) diff --git a/content/solutions/05_09.py b/content/solutions/05_09.py index 5476dda..fcc6fae 100644 --- a/content/solutions/05_09.py +++ b/content/solutions/05_09.py @@ -1 +1,11 @@ -df.index \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +print('df.index') +display(df.index) diff --git a/content/solutions/05_10.py b/content/solutions/05_10.py index cfad187..193a595 100644 --- a/content/solutions/05_10.py +++ b/content/solutions/05_10.py @@ -1,5 +1,17 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + df = df.reset_index() df.index # We could also have done the following when concatenating: -# df = pd.concat(frames, ignore_index=True) \ No newline at end of file +# df = pd.concat(frames, ignore_index=True) + +print('df.reset_index()\ndf.index\n') +display(df.index) \ No newline at end of file diff --git a/content/solutions/05_11.py b/content/solutions/05_11.py index e1ed112..f3297fb 100644 --- a/content/solutions/05_11.py +++ b/content/solutions/05_11.py @@ -1 +1,14 @@ -df.info() \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() + +print('df.info\n') + +display(df.info()) \ No newline at end of file diff --git a/content/solutions/05_12.py b/content/solutions/05_12.py index 1cc1893..3326a4e 100644 --- a/content/solutions/05_12.py +++ b/content/solutions/05_12.py @@ -1 +1,8 @@ -?pd.DataFrame.drop \ No newline at end of file +import pandas as pd + +print('?pd.DataFrame.drop)') + +# help(pd.DataFrame.drop) + +# You can also use +# ?pd.DataFrame.drop \ No newline at end of file diff --git a/content/solutions/05_13.py b/content/solutions/05_13.py index fde2e4f..3205dbf 100644 --- a/content/solutions/05_13.py +++ b/content/solutions/05_13.py @@ -1,2 +1,17 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] -df = df.drop(cols_to_remove, axis=1) \ No newline at end of file +df = df.drop(cols_to_remove, axis=1) + +print('cols_to_remove = ["Unnamed: 5", "Unnamed: 6"]') +print('df = df.drop(cols_to_remove, axis=1)') \ No newline at end of file diff --git a/content/solutions/05_14.py b/content/solutions/05_14.py index 59ca733..5975a62 100644 --- a/content/solutions/05_14.py +++ b/content/solutions/05_14.py @@ -1 +1,18 @@ -df["Location"].unique() \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +print('df["Location"].unique()\n') + +display(df["Location"].unique()) \ No newline at end of file diff --git a/content/solutions/05_15.py b/content/solutions/05_15.py index d1e771b..7d2d2ef 100644 --- a/content/solutions/05_15.py +++ b/content/solutions/05_15.py @@ -1 +1,18 @@ -df["Location"].str.split(pat=";") \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +print('df["Location"].str.split(pat=";")\n') + +display(df["Location"].str.split(pat=";")) \ No newline at end of file diff --git a/content/solutions/05_16.py b/content/solutions/05_16.py index b4c40f0..b18ccd7 100644 --- a/content/solutions/05_16.py +++ b/content/solutions/05_16.py @@ -1 +1,18 @@ -df["Location"].str.split(pat=";", expand=True) \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +print('df["Location"].str.split(pat=";", expand=True)\n') + +display(df["Location"].str.split(pat=";", expand=True)) \ No newline at end of file diff --git a/content/solutions/05_17.py b/content/solutions/05_17.py index ce9645a..f1c0f23 100644 --- a/content/solutions/05_17.py +++ b/content/solutions/05_17.py @@ -1 +1,20 @@ -df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +print('df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True)\n') + +display(df) \ No newline at end of file diff --git a/content/solutions/05_18.py b/content/solutions/05_18.py index 7381102..68d1bac 100644 --- a/content/solutions/05_18.py +++ b/content/solutions/05_18.py @@ -1 +1,20 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +print('df = df.drop("Location", axis=1)\n') + df = df.drop("Location", axis=1) \ No newline at end of file diff --git a/content/solutions/05_19.py b/content/solutions/05_19.py index 0c3641f..896b59a 100644 --- a/content/solutions/05_19.py +++ b/content/solutions/05_19.py @@ -1 +1,22 @@ -df["country"].nunique() \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +print('df["country"].nunique()\n') + +display(df["country"].nunique()) \ No newline at end of file diff --git a/content/solutions/05_20.py b/content/solutions/05_20.py index 2dd0467..4b366b3 100644 --- a/content/solutions/05_20.py +++ b/content/solutions/05_20.py @@ -1 +1,22 @@ -df["country"].value_counts() \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +print('df["country"].value_counts()\n') + +display(df["country"].value_counts()) \ No newline at end of file diff --git a/content/solutions/05_21.py b/content/solutions/05_21.py index 4411e2d..fcfae9a 100644 --- a/content/solutions/05_21.py +++ b/content/solutions/05_21.py @@ -1,2 +1,23 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +print('df["country"] = df["country"].str.strip()\ndf["city"] = df["city"].str.strip()\n') + df["country"] = df["country"].str.strip() df["city"] = df["city"].str.strip() \ No newline at end of file diff --git a/content/solutions/05_22.py b/content/solutions/05_22.py index 0c3641f..8d64964 100644 --- a/content/solutions/05_22.py +++ b/content/solutions/05_22.py @@ -1 +1,22 @@ -df["country"].nunique() \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +print('df["country"].nunique()') + +display(df["country"].nunique()) \ No newline at end of file diff --git a/content/solutions/05_23.py b/content/solutions/05_23.py index 571e1d7..f15504d 100644 --- a/content/solutions/05_23.py +++ b/content/solutions/05_23.py @@ -1 +1,22 @@ -df[df["country"] == "Portugal"] \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +print('df[df["country"] == "Portugal"]\n') + +display(df[df["country"] == "Portugal"]) \ No newline at end of file diff --git a/content/solutions/05_24.py b/content/solutions/05_24.py index 1260c3f..3df1249 100644 --- a/content/solutions/05_24.py +++ b/content/solutions/05_24.py @@ -1 +1,23 @@ -df["city"] = df["city"].str.lower() \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +print('df["city"] = df["city"].str.lower()\n') + +df["city"] = df["city"].str.lower() +display(df[df["country"] == "Portugal"]) \ No newline at end of file diff --git a/content/solutions/05_25.py b/content/solutions/05_25.py index 0db9542..e7149ba 100644 --- a/content/solutions/05_25.py +++ b/content/solutions/05_25.py @@ -1 +1,24 @@ -df["city"][df["city"].str.contains("/")] \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +print('df["city"][df["city"].str.contains("/")]\n') + +display(df["city"][df["city"].str.contains("/")]) \ No newline at end of file diff --git a/content/solutions/05_26.py b/content/solutions/05_26.py index 218e64b..84d9087 100644 --- a/content/solutions/05_26.py +++ b/content/solutions/05_26.py @@ -1 +1,26 @@ -df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +print('df["city"] = df["city"].str.replace(r"/\w*", "", regex=True)\n') + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +# display(df["city"].tail()) \ No newline at end of file diff --git a/content/solutions/05_27.py b/content/solutions/05_27.py index 87c78b0..7426db5 100644 --- a/content/solutions/05_27.py +++ b/content/solutions/05_27.py @@ -1,3 +1,26 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + dict_codes = { "BG": "Bulgaria", "CZ": "Czech Republic", @@ -8,4 +31,6 @@ } country_in_codes = df["country"].isin(dict_codes.keys()) -df.loc[country_in_codes, "country"] = df.loc[country_in_codes, "country"].map(dict_codes) \ No newline at end of file +df.loc[country_in_codes, "country"] = df.loc[country_in_codes, "country"].map(dict_codes) + +print('df.loc[country_in_codes, "country"] = df.loc[country_in_codes, "country"].map(dict_codes)') \ No newline at end of file diff --git a/content/solutions/05_28.py b/content/solutions/05_28.py index e4b0e00..1acc786 100644 --- a/content/solutions/05_28.py +++ b/content/solutions/05_28.py @@ -1 +1,38 @@ -df.loc[df["city"] == "unknown", "country"] \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_codes = { + "BG": "Bulgaria", + "CZ": "Czech Republic", + "IT": "Italy", + "GR": "Greece", + "SI": "Slovenia", + "UK": "United Kingdom", +} + +country_in_codes = df["country"].isin(dict_codes.keys()) +df.loc[country_in_codes, "country"] = df.loc[country_in_codes, "country"].map(dict_codes) + +print('df.loc[df["city"] == "unknown", "country"]\n') + +display(df.loc[df["city"] == "unknown", "country"]) \ No newline at end of file diff --git a/content/solutions/05_29.py b/content/solutions/05_29.py index fc41745..a90e3df 100644 --- a/content/solutions/05_29.py +++ b/content/solutions/05_29.py @@ -1,3 +1,26 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + dict_capitals = { "Denmark": "copenhague", "France": "paris", @@ -7,4 +30,7 @@ } unknown_city = df["city"] == "unknown" -df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) \ No newline at end of file +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +print('unknown_city = df["city"] == "unknown"') +print('df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals)') \ No newline at end of file diff --git a/content/solutions/05_30.py b/content/solutions/05_30.py index 1f54a6c..cba83dd 100644 --- a/content/solutions/05_30.py +++ b/content/solutions/05_30.py @@ -1 +1,39 @@ -set(df["city"]) - dict_cities.keys() \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +print('set(df["city"]) - dict_cities.keys()\n') + +display(set(df["city"]) - dict_cities.keys()) diff --git a/content/solutions/05_31.py b/content/solutions/05_31.py index c4c9fec..2177ef0 100644 --- a/content/solutions/05_31.py +++ b/content/solutions/05_31.py @@ -1,3 +1,39 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + dict_cities.update( { "bristol": "United Kingdom", @@ -7,4 +43,6 @@ "murcia": "Spain", "parma": "Italy", }, -) \ No newline at end of file +) + +print("dict_cities.update(\n{\n\t\"bristol\": \"United Kingdom\",\n\t\"gothenburg\": \"Sweden\",\n\t\"graz\": \"Austria\",\n\t\"lyon\": \"France\",\n\t \"murcia\": \"Spain\",\n\t \"parma\": \"Italy\",\n},\n)\n") \ No newline at end of file diff --git a/content/solutions/05_32.py b/content/solutions/05_32.py index 3b4a6e2..3a0a599 100644 --- a/content/solutions/05_32.py +++ b/content/solutions/05_32.py @@ -1,2 +1,52 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + null_country = df["country"].isnull() -df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) \ No newline at end of file +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +print('null_country = df["country"].isnull()') +print('df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities)') \ No newline at end of file diff --git a/content/solutions/05_33.py b/content/solutions/05_33.py index 689a6ca..8085ccf 100644 --- a/content/solutions/05_33.py +++ b/content/solutions/05_33.py @@ -1 +1,53 @@ -df["country"].value_counts(dropna=False) \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +print('df["country"].value_counts(dropna=False)\n') + +display(df["country"].value_counts(dropna=False)) \ No newline at end of file diff --git a/content/solutions/05_34.py b/content/solutions/05_34.py index 63c70f8..eea2930 100644 --- a/content/solutions/05_34.py +++ b/content/solutions/05_34.py @@ -2,4 +2,12 @@ def f(x): if x == 1: return "single" else: - return "multiple" \ No newline at end of file + return "multiple" + +print('def f(x):') +print('\tif x == 1:') +print('\t\treturn "single"') +print('\telse:') +print('\t\treturn "multiple"\n') + +print('f(4) = ',f(4)) #x = 4 \ No newline at end of file diff --git a/content/solutions/05_35.py b/content/solutions/05_35.py index db3b33e..4e54e09 100644 --- a/content/solutions/05_35.py +++ b/content/solutions/05_35.py @@ -1 +1,62 @@ -df["Attendees"].apply(f) \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +print('df["Attendees"].apply(f)\n') + +display(df["Attendees"].apply(f)) diff --git a/content/solutions/05_36.py b/content/solutions/05_36.py index 82e7848..75ac002 100644 --- a/content/solutions/05_36.py +++ b/content/solutions/05_36.py @@ -1 +1,5 @@ -languages = pd.read_csv("../data/food_training/languages.csv") \ No newline at end of file +import pandas as pd + +languages = pd.read_csv("../data/food_training/languages.csv") + +print('languages = pd.read_csv("../data/food_training/languages.csv")') \ No newline at end of file diff --git a/content/solutions/05_37.py b/content/solutions/05_37.py index f712fd9..3277a91 100644 --- a/content/solutions/05_37.py +++ b/content/solutions/05_37.py @@ -1 +1,68 @@ -df = df.merge(languages, how="left", left_on="country", right_on="Country") \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + +print('df = df.merge(languages, how="left", left_on="country", right_on="Country")\n') +display(df) \ No newline at end of file diff --git a/content/solutions/05_38.py b/content/solutions/05_38.py index f2614a1..4c27890 100644 --- a/content/solutions/05_38.py +++ b/content/solutions/05_38.py @@ -1,5 +1,75 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + df = df.drop("Country", axis=1) +print('df = df.drop("Country", axis=1)') + +display(df) + # N.B. You can only run this cell once! If you try run it again, it will throw an error! # Why? Because if you drop the Country column, it will be removed...so you can't # drop it a second time as the column isn't there to drop! \ No newline at end of file diff --git a/content/solutions/05_39.py b/content/solutions/05_39.py index d9d3e45..fc708eb 100644 --- a/content/solutions/05_39.py +++ b/content/solutions/05_39.py @@ -1 +1,71 @@ -df["DateFrom"].dtype \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + +df = df.drop("Country", axis=1) + +print('df["DateFrom"].dtype)\n') + +display(df["DateFrom"].dtype) \ No newline at end of file diff --git a/content/solutions/05_40.py b/content/solutions/05_40.py index eef6325..d0d8bfa 100644 --- a/content/solutions/05_40.py +++ b/content/solutions/05_40.py @@ -1,2 +1,73 @@ +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + +df = df.drop("Country", axis=1) + +print('df["DateFrom"] = pd.to_datetime(df["DateFrom"], format="%Y-%m-%d")\n') +print('df["DateTo"] = pd.to_datetime(df["DateTo"], format="%Y-%m-%d")') + df["DateFrom"] = pd.to_datetime(df["DateFrom"], format="%Y-%m-%d") df["DateTo"] = pd.to_datetime(df["DateTo"], format="%Y-%m-%d") \ No newline at end of file diff --git a/content/solutions/05_41.py b/content/solutions/05_41.py index 3a34721..213b28e 100644 --- a/content/solutions/05_41.py +++ b/content/solutions/05_41.py @@ -1 +1,73 @@ -df[df["DateFrom"] > "2017-02-01"] \ No newline at end of file +import pandas as pd + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + +df = df.drop("Country", axis=1) + +df["DateFrom"] = pd.to_datetime(df["DateFrom"], format="%Y-%m-%d") +df["DateTo"] = pd.to_datetime(df["DateTo"], format="%Y-%m-%d") + +print('df[df["DateFrom"] > "2017-02-01"]\n') +display(df[df["DateFrom"] > "2017-02-01"]) diff --git a/content/solutions/05_42.py b/content/solutions/05_42.py index 73aa5d3..4341063 100644 --- a/content/solutions/05_42.py +++ b/content/solutions/05_42.py @@ -1 +1,75 @@ -df["duration"] = df["DateTo"] - df["DateFrom"] + datetime.timedelta(days=1) \ No newline at end of file +import pandas as pd +import datetime + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + +df = df.drop("Country", axis=1) + +df["DateFrom"] = pd.to_datetime(df["DateFrom"], format="%Y-%m-%d") +df["DateTo"] = pd.to_datetime(df["DateTo"], format="%Y-%m-%d") + +print('df["duration"] = df["DateTo"] - df["DateFrom"] + datetime.timedelta(days=1)\n') +df["duration"] = df["DateTo"] - df["DateFrom"] + datetime.timedelta(days=1) +display(df.head()) \ No newline at end of file diff --git a/content/solutions/05_43.py b/content/solutions/05_43.py index 49c09b5..58cf6a7 100644 --- a/content/solutions/05_43.py +++ b/content/solutions/05_43.py @@ -1,2 +1,79 @@ +import pandas as pd +import datetime + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + +df = df.drop("Country", axis=1) + +df["DateFrom"] = pd.to_datetime(df["DateFrom"], format="%Y-%m-%d") +df["DateTo"] = pd.to_datetime(df["DateTo"], format="%Y-%m-%d") + +df["duration"] = df["DateTo"] - df["DateFrom"] + datetime.timedelta(days=1) + +print('df["month"] = df["DateFrom"].dt.month\n') +print('df["month"].hist()\n') + df["month"] = df["DateFrom"].dt.month -df["month"].hist() \ No newline at end of file +# display(df) +display(df["month"].hist()) \ No newline at end of file diff --git a/content/solutions/05_44.py b/content/solutions/05_44.py index bad939c..1dedd50 100644 --- a/content/solutions/05_44.py +++ b/content/solutions/05_44.py @@ -1 +1,69 @@ -df.sort_values("city") \ No newline at end of file +import pandas as pd +import datetime + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + +print('df.sort_values("city")\n') + +display(df.sort_values("city")) \ No newline at end of file diff --git a/content/solutions/05_45.py b/content/solutions/05_45.py index 3491680..b1bb085 100644 --- a/content/solutions/05_45.py +++ b/content/solutions/05_45.py @@ -1 +1,77 @@ -df.sort_values(["duration", "Attendees"], ascending=[True, False]) \ No newline at end of file +import pandas as pd +import datetime + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + +df = df.drop("Country", axis=1) + +df["DateFrom"] = pd.to_datetime(df["DateFrom"], format="%Y-%m-%d") +df["DateTo"] = pd.to_datetime(df["DateTo"], format="%Y-%m-%d") + +df["duration"] = df["DateTo"] - df["DateFrom"] + datetime.timedelta(days=1) + +df["month"] = df["DateFrom"].dt.month + +print('df.sort_values(["duration", "Attendees"], ascending=[True, False])') +display(df.sort_values(["duration", "Attendees"], ascending=[True, False])) \ No newline at end of file diff --git a/content/solutions/05_46.py b/content/solutions/05_46.py index 67dd12e..f3856a6 100644 --- a/content/solutions/05_46.py +++ b/content/solutions/05_46.py @@ -1 +1,79 @@ -df_gr = df.groupby("city") \ No newline at end of file +import pandas as pd +import datetime + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + +df = df.drop("Country", axis=1) + +df["DateFrom"] = pd.to_datetime(df["DateFrom"], format="%Y-%m-%d") +df["DateTo"] = pd.to_datetime(df["DateTo"], format="%Y-%m-%d") + +df["duration"] = df["DateTo"] - df["DateFrom"] + datetime.timedelta(days=1) + +df["month"] = df["DateFrom"].dt.month +df.sort_values(["duration", "Attendees"], ascending=[True, False]) + +print('df_gr = df.groupby("city")') +df_gr = df.groupby("city") + diff --git a/content/solutions/05_47.py b/content/solutions/05_47.py index c7520eb..21e7bb5 100644 --- a/content/solutions/05_47.py +++ b/content/solutions/05_47.py @@ -1 +1,80 @@ -df_gr["Attendees"].mean() \ No newline at end of file +import pandas as pd +import datetime + +df_2014 = pd.read_csv("../data/food_training/training_2014.csv", header=1) +df_2015 = pd.read_csv("../data/food_training/training_2015.csv", header=1) +df_2016 = pd.read_csv("../data/food_training/training_2016.csv", header=1) + +frames = [df_2014, df_2015, df_2016] +df = pd.concat(frames) + +df = df.reset_index() +df.index + +cols_to_remove = ["Unnamed: 5", "Unnamed: 6"] +df = df.drop(cols_to_remove, axis=1) + +df[["city", "country"]] = df["Location"].str.split(pat=";", expand=True) + +df = df.drop("Location", axis=1) + +df["city"] = df["city"].str.lower() + +df["city"] = df["city"].str.replace(r"/\w*", "", regex=True) + +dict_capitals = { + "Denmark": "copenhague", + "France": "paris", + "Italy": "rome", + "Spain": "madrid", + "United Kingdom": "london", +} + +unknown_city = df["city"] == "unknown" +df.loc[unknown_city, "city"] = df.loc[unknown_city, "country"].map(dict_capitals) + +dict_cities = df.loc[df['country'].notnull(), ['city', 'country']].set_index('city').to_dict()['country'] + +dict_cities.update( + { + "bristol": "United Kingdom", + "gothenburg": "Sweden", + "graz": "Austria", + "lyon": "France", + "murcia": "Spain", + "parma": "Italy", + }, +) + +null_country = df["country"].isnull() +df.loc[null_country, "country"] = df.loc[null_country, "city"].map(dict_cities) + +df["country"].value_counts(dropna=False) + + +def f(x): + if x == 1: + return "single" + else: + return "multiple" + +df["Attendees"].apply(f) + +languages = pd.read_csv("../data/food_training/languages.csv") + +df = df.merge(languages, how="left", left_on="country", right_on="Country") + +df = df.drop("Country", axis=1) + +df["DateFrom"] = pd.to_datetime(df["DateFrom"], format="%Y-%m-%d") +df["DateTo"] = pd.to_datetime(df["DateTo"], format="%Y-%m-%d") + +df["duration"] = df["DateTo"] - df["DateFrom"] + datetime.timedelta(days=1) + +df["month"] = df["DateFrom"].dt.month +df.sort_values(["duration", "Attendees"], ascending=[True, False]) + +df_gr = df.groupby("city") + +print('df_gr["Attendees"].mean()') +display(df_gr["Attendees"].mean()) \ No newline at end of file