diff --git a/IntroToPythonForDataScience.ipynb b/IntroToPythonForDataScience.ipynb new file mode 100644 index 0000000..0e9c891 --- /dev/null +++ b/IntroToPythonForDataScience.ipynb @@ -0,0 +1,3252 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction to Python for Data Science\n", + "\n", + "This jupyter notebook is adapted from the [**FREE** Edx course](https://www.edx.org/course/introduction-python-data-science-microsoft-dat208x-6) of the same title. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%html\n", + " \n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1.1. Hello Python\n", + "\n", + "## What you will learn\n", + "- Python\n", + "- Specifically for Data Science\n", + "- Store data\n", + "- Manipulate data\n", + "- Tools for data analysis\n", + "\n", + "## Python\n", + "- Guido Van Rossum\n", + "- General Purpose: build anything\n", + "- Open Source! Free!\n", + "- Python Packages, also for Data Science\n", + "- Many applications and fields\n", + "- [Version 2.7 or 3.x](https://wiki.python.org/moin/Python2orPython3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1.2. Variables and Types\n", + "\n", + "- Specific, case-sensitive name\n", + "- Call up value through variable name" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "height = 1.79\n", + "weight = 68.7" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.79" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "height" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Calculate BMI\n", + "\n", + "- Definition: $ \\text{BMI} = \\frac{\\text{weight}}{\\text{height}^2} $" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21.44127836209856\n" + ] + } + ], + "source": [ + "height = 1.79\n", + "weight = 68.7\n", + "bmi = weight / height ** 2\n", + "print(bmi)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21.44127836209856\n" + ] + } + ], + "source": [ + "# changing height or weight does not alter bmi\n", + "height = 1.34\n", + "print(bmi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Python Data Types\n", + "\n", + "- float - real numbers\n", + "- int - integer numbers\n", + "- str - string, text\n", + "- bool - True, False" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "float" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(bmi)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "int" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "day_of_week = 5\n", + "type(day_of_week)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "str" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = \"body mass index\"\n", + "type(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "str" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y = 'this works too'\n", + "type(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "bool" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "z = True\n", + "type(z)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "abcd\n" + ] + } + ], + "source": [ + "# Different type = different behavior!\n", + "print(2 + 3)\n", + "print('ab' + 'cd')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2.1. Python `List`\n", + "\n", + "## Python Data Types\n", + "- `float` - real numbers\n", + "- `int` - integer numbers\n", + "- `str` - string, text\n", + "- `bool` - True, False\n", + "- Each variable represents ***single*** value\n", + "\n", + "## Problem\n", + "- Data Science: many data points\n", + "- Height of entire family\n", + "```Python\n", + "In [3]: height1 = 1.73\n", + "In [4]: height2 = 1.68\n", + "In [5]: height3 = 1.71\n", + "In [6]: height4 = 1.89\n", + "```\n", + "- Inconvenient\n", + "\n", + "## Python `List`\n", + "- Name a collection of values\n", + "- Contain any type\n", + "- Contain different types" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "list" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Basic list\n", + "fam = [1.73, 1.68, 1.71, 1.89]\n", + "type(fam)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "list" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# List with multiple types\n", + "fam = [\"liz\", 1.73, \"emma\", 1.68, \"mom\", 1.71, \"dad\", 1.89]\n", + "type(fam)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "list" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# List of lists\n", + "fam2 = [[\"liz\", 1.73], [\"emma\", 1.68], [\"mom\", 1.71], [\"dad\", 1.89]]\n", + "type(fam)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2.2. Subsetting lists\n", + "\n", + "Zero-based indexing: \n", + "\n", + "- $0, 1, 2,\\dots, N-2, N-1$\n", + "- $-(N-1), -(N-2), \\dots , -2, -1$\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.68" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam[3]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'dad'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam[6]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.89" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'dad'" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam[-2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## List slicing \n", + "\n", + "[ start (inclusive) : end (exclusive) ]" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1.68, 'mom']" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam[3:5]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1.73, 'emma', 1.68]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam[1:4]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['liz', 1.73, 'emma', 1.68]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam[:4]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1.71, 'dad', 1.89]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam[5:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2.3. Manipulating Lists\n", + "\n", + "- Change list elements\n", + "- Add list elements\n", + "- Remove list elements\n", + "\n", + "## Changing list elements\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "fam[7] = 1.86" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.86]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "fam[0:2] = [\"lisa\", 1.74]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['lisa', 1.74, 'emma', 1.68, 'mom', 1.71, 'dad', 1.86]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adding and removing elements" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['lisa', 1.74, 'emma', 1.68, 'mom', 1.71, 'dad', 1.86, 'me', 1.79]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam_ext = fam + [\"me\", 1.79]\n", + "fam_ext" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['lisa', 1.74, 1.68, 'mom', 1.71, 'dad', 1.86]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "del(fam[2])\n", + "fam" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['lisa', 1.74, 'mom', 1.71, 'dad', 1.86]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "del(fam[2])\n", + "fam" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Copying Lists\n", + "\n", + "- copying by reference\n", + "- copying by value " + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['a', 'z', 'c']\n", + "['a', 'z', 'c']\n" + ] + } + ], + "source": [ + "# Copy by reference (change the copy, change the original)\n", + "x = [\"a\", \"b\", \"c\"]\n", + "y = x\n", + "y[1] = \"z\"\n", + "print(x)\n", + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['a', 'b', 'c']\n", + "['a', 'z', 'c']\n" + ] + } + ], + "source": [ + "# Copy by value (change the copy, no change to the original)\n", + "x = [\"a\", \"b\", \"c\"]\n", + "y = x[:] # or y = list(x)\n", + "y[1] = \"z\"\n", + "print(x)\n", + "print(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3.1. Functions\n", + "\n", + "- Nothing new!\n", + "- `type()`\n", + "- Piece of reusable code\n", + "- Solves particular task\n", + "- Call function instead of writing code yourself\n", + "\n", + "## Example 1: max( ) function\n", + "\n", + "Find the largest element in a list." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.89\n" + ] + } + ], + "source": [ + "fam = [1.73, 1.68, 1.71, 1.89]\n", + "tallest = max(fam)\n", + "print(tallest)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2: round( ) function\n", + "\n", + "Round floating point number." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on built-in function round in module builtins:\n", + "\n", + "round(...)\n", + " round(number[, ndigits]) -> number\n", + " \n", + " Round a number to a given precision in decimal digits (default 0 digits).\n", + " This returns an int when called with one argument, otherwise the\n", + " same type as the number. ndigits may be negative.\n", + "\n" + ] + } + ], + "source": [ + "help(round)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.7" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "round(1.68,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "round(1.68)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finding functions\n", + "\n", + "- Standard task $\\rightarrow$ probably function exists!\n", + "- The internet is your friend (google it!)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3.2 Methods: Functions that belong to objects\n", + "\n", + "- `str` : capitalize(), replace(), etc.\n", + "- `float` : bit_length(), conjugate(), etc.\n", + "- `list` : intex(), count(), etc.\n", + "\n", + "## `list` Methods" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam = ['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89]\n", + "fam.index(\"mom\")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam.count(1.73)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `str` Methods" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'liz'" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sister = \"liz\"\n", + "sister" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Liz'" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sister.capitalize()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'lisa'" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sister.replace(\"z\", \"sa\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Methods\n", + "- Everything = object\n", + "- Object have methods associated, depending on type" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'replace'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfam\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreplace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"mom\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"mommy\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'replace'" + ] + } + ], + "source": [ + "fam.replace(\"mom\", \"mommy\")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sister.index(\"z\")" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'me']" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam.append(\"me\")\n", + "fam" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['liz', 1.73, 'emma', 1.68, 'mom', 1.71, 'dad', 1.89, 'me', '1.79']" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fam.append(\"1.79\")\n", + "fam" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "- Functions\n", + " - `type(fam)`\n", + "- Methods: call functions on objects\n", + " - `fam.index(\"dad\")`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3.3 Packages\n", + "\n", + "## Motivation\n", + "\n", + "- Functions and methods are powerful\n", + "- All code in Python distribution?\n", + " - Huge code base: messy\n", + " - Lots of code you won’t use\n", + " - Maintenance problem\n", + "\n", + "## Packages\n", + "\n", + "- Directory of Python Scripts\n", + "- Each script = module\n", + "- Specify functions, methods, types\n", + "- Thousands of packages available\n", + " - Numpy\n", + " - Matplotlib\n", + " - Scikit-learn\n", + "\n", + "## Install package\n", + "- http://pip.readthedocs.org/en/stable/installing/\n", + "- Download get-pip.py\n", + "- Terminal:\n", + " - python get-pip.py\n", + " - pip install numpy\n", + " \n", + "## Import package" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'array' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'array' is not defined" + ] + } + ], + "source": [ + "import numpy\n", + "array([1, 2, 3])" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3])" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.array([1, 2, 3])" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3])" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "np.array([1, 2, 3])" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3])" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from numpy import array\n", + "array([1, 2, 3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4.1 Numpy\n", + "\n", + "## Lists Recap\n", + "- Powerful\n", + "- Collection of values\n", + "- Hold different types\n", + "- Change, add, remove\n", + "- Need for Data Science\n", + " - Mathematical operations over collections\n", + " - Speed\n", + "\n", + "## Illustration" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1.73, 1.68, 1.71, 1.89, 1.79]" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "height = [1.73, 1.68, 1.71, 1.89, 1.79]\n", + "height" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[65.4, 59.2, 63.6, 88.4, 68.7]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "weight = [65.4, 59.2, 63.6, 88.4, 68.7]\n", + "weight" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for ** or pow(): 'list' and 'int'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mweight\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mheight\u001b[0m \u001b[0;34m**\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'list' and 'int'" + ] + } + ], + "source": [ + "weight / height ** 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solution: Numpy\n", + "- Numeric Python\n", + "- Alternative to Python List: Numpy Array\n", + "- Calculations over entire arrays\n", + "- Easy and Fast\n", + "- Installation\n", + " - In the terminal: pip3 install numpy" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1.73, 1.68, 1.71, 1.89, 1.79])" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "np_height = np.array(height)\n", + "np_height" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 65.4, 59.2, 63.6, 88.4, 68.7])" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np_weight = np.array(weight)\n", + "np_weight" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 21.85171573, 20.97505669, 21.75028214, 24.7473475 , 21.44127836])" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Element-wise calculations\n", + "bmi = np_weight / np_height ** 2\n", + "bmi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Numpy: remarks\n", + "- Numpy arrays: contain only one type\n", + "- Different types: different behavior!" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['1.0', 'is', 'True'], \n", + " dtype=' 23" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 24.7473475])" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bmi[bmi > 23]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4.2. 2D Numpy Arrays\n", + "\n", + "## Type of Numpy Arrays\n", + "- ndarray = N-dimensional array" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "np_height = np.array([1.73, 1.68, 1.71, 1.89, 1.79])\n", + "np_weight = np.array([65.4, 59.2, 63.6, 88.4, 68.7])" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "numpy.ndarray" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(np_height)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "numpy.ndarray" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(np_weight)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2D Numpy Arrays" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.73, 1.68, 1.71, 1.89, 1.79],\n", + " [ 65.4 , 59.2 , 63.6 , 88.4 , 68.7 ]])" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np_2d = np.array([[1.73, 1.68, 1.71, 1.89, 1.79],[65.4, 59.2, 63.6, 88.4, 68.7]])\n", + "np_2d" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 5)" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 2 rows, 5 columns\n", + "np_2d.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([['1.73', '1.68', '1.71', '1.89', '1.79'],\n", + " ['65.4', '59.2', '63.6', '88.4', '68.7']], \n", + " dtype='" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "year = [1950, 1970, 1990, 2010]\n", + "pop = [2.519, 3.692, 5.263, 6.972]\n", + "plt.plot(year, pop)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scatter plot" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nFWNwS1IxBrckFWNwS1IxBrckFfN/LLHdYRAi3wAAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(year, pop)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 5.2. Histograms\n", + "\n", + "## Histogram\n", + "- Explore dataset\n", + "- Get idea about distribution\n", + "\n", + "## Matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function hist in module matplotlib.pyplot:\n", + "\n", + "hist(x, bins=None, range=None, normed=False, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, hold=None, data=None, **kwargs)\n", + " Plot a histogram.\n", + " \n", + " Compute and draw the histogram of *x*. The return value is a\n", + " tuple (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*,\n", + " [*patches0*, *patches1*,...]) if the input contains multiple\n", + " data.\n", + " \n", + " Multiple data can be provided via *x* as a list of datasets\n", + " of potentially different length ([*x0*, *x1*, ...]), or as\n", + " a 2-D ndarray in which each column is a dataset. Note that\n", + " the ndarray form is transposed relative to the list form.\n", + " \n", + " Masked arrays are not supported at present.\n", + " \n", + " Parameters\n", + " ----------\n", + " x : (n,) array or sequence of (n,) arrays\n", + " Input values, this takes either a single array or a sequency of\n", + " arrays which are not required to be of the same length\n", + " \n", + " bins : integer or array_like or 'auto', optional\n", + " If an integer is given, `bins + 1` bin edges are returned,\n", + " consistently with :func:`numpy.histogram` for numpy version >=\n", + " 1.3.\n", + " \n", + " Unequally spaced bins are supported if `bins` is a sequence.\n", + " \n", + " If Numpy 1.11 is installed, may also be ``'auto'``.\n", + " \n", + " Default is taken from the rcParam ``hist.bins``.\n", + " \n", + " range : tuple or None, optional\n", + " The lower and upper range of the bins. Lower and upper outliers\n", + " are ignored. If not provided, `range` is (x.min(), x.max()). Range\n", + " has no effect if `bins` is a sequence.\n", + " \n", + " If `bins` is a sequence or `range` is specified, autoscaling\n", + " is based on the specified bin range instead of the\n", + " range of x.\n", + " \n", + " Default is ``None``\n", + " \n", + " normed : boolean, optional\n", + " If `True`, the first element of the return tuple will\n", + " be the counts normalized to form a probability density, i.e.,\n", + " ``n/(len(x)`dbin)``, i.e., the integral of the histogram will sum\n", + " to 1. If *stacked* is also *True*, the sum of the histograms is\n", + " normalized to 1.\n", + " \n", + " Default is ``False``\n", + " \n", + " weights : (n, ) array_like or None, optional\n", + " An array of weights, of the same shape as `x`. Each value in `x`\n", + " only contributes its associated weight towards the bin count\n", + " (instead of 1). If `normed` is True, the weights are normalized,\n", + " so that the integral of the density over the range remains 1.\n", + " \n", + " Default is ``None``\n", + " \n", + " cumulative : boolean, optional\n", + " If `True`, then a histogram is computed where each bin gives the\n", + " counts in that bin plus all bins for smaller values. The last bin\n", + " gives the total number of datapoints. If `normed` is also `True`\n", + " then the histogram is normalized such that the last bin equals 1.\n", + " If `cumulative` evaluates to less than 0 (e.g., -1), the direction\n", + " of accumulation is reversed. In this case, if `normed` is also\n", + " `True`, then the histogram is normalized such that the first bin\n", + " equals 1.\n", + " \n", + " Default is ``False``\n", + " \n", + " bottom : array_like, scalar, or None\n", + " Location of the bottom baseline of each bin. If a scalar,\n", + " the base line for each bin is shifted by the same amount.\n", + " If an array, each bin is shifted independently and the length\n", + " of bottom must match the number of bins. If None, defaults to 0.\n", + " \n", + " Default is ``None``\n", + " \n", + " histtype : {'bar', 'barstacked', 'step', 'stepfilled'}, optional\n", + " The type of histogram to draw.\n", + " \n", + " - 'bar' is a traditional bar-type histogram. If multiple data\n", + " are given the bars are aranged side by side.\n", + " \n", + " - 'barstacked' is a bar-type histogram where multiple\n", + " data are stacked on top of each other.\n", + " \n", + " - 'step' generates a lineplot that is by default\n", + " unfilled.\n", + " \n", + " - 'stepfilled' generates a lineplot that is by default\n", + " filled.\n", + " \n", + " Default is 'bar'\n", + " \n", + " align : {'left', 'mid', 'right'}, optional\n", + " Controls how the histogram is plotted.\n", + " \n", + " - 'left': bars are centered on the left bin edges.\n", + " \n", + " - 'mid': bars are centered between the bin edges.\n", + " \n", + " - 'right': bars are centered on the right bin edges.\n", + " \n", + " Default is 'mid'\n", + " \n", + " orientation : {'horizontal', 'vertical'}, optional\n", + " If 'horizontal', `~matplotlib.pyplot.barh` will be used for\n", + " bar-type histograms and the *bottom* kwarg will be the left edges.\n", + " \n", + " rwidth : scalar or None, optional\n", + " The relative width of the bars as a fraction of the bin width. If\n", + " `None`, automatically compute the width.\n", + " \n", + " Ignored if `histtype` is 'step' or 'stepfilled'.\n", + " \n", + " Default is ``None``\n", + " \n", + " log : boolean, optional\n", + " If `True`, the histogram axis will be set to a log scale. If `log`\n", + " is `True` and `x` is a 1D array, empty bins will be filtered out\n", + " and only the non-empty (`n`, `bins`, `patches`) will be returned.\n", + " \n", + " Default is ``False``\n", + " \n", + " color : color or array_like of colors or None, optional\n", + " Color spec or sequence of color specs, one per dataset. Default\n", + " (`None`) uses the standard line color sequence.\n", + " \n", + " Default is ``None``\n", + " \n", + " label : string or None, optional\n", + " String, or sequence of strings to match multiple datasets. Bar\n", + " charts yield multiple patches per dataset, but only the first gets\n", + " the label, so that the legend command will work as expected.\n", + " \n", + " default is ``None``\n", + " \n", + " stacked : boolean, optional\n", + " If `True`, multiple data are stacked on top of each other If\n", + " `False` multiple data are aranged side by side if histtype is\n", + " 'bar' or on top of each other if histtype is 'step'\n", + " \n", + " Default is ``False``\n", + " \n", + " Returns\n", + " -------\n", + " n : array or list of arrays\n", + " The values of the histogram bins. See **normed** and **weights**\n", + " for a description of the possible semantics. If input **x** is an\n", + " array, then this is an array of length **nbins**. If input is a\n", + " sequence arrays ``[data1, data2,..]``, then this is a list of\n", + " arrays with the values of the histograms for each of the arrays\n", + " in the same order.\n", + " \n", + " bins : array\n", + " The edges of the bins. Length nbins + 1 (nbins left edges and right\n", + " edge of last bin). Always a single array even when multiple data\n", + " sets are passed in.\n", + " \n", + " patches : list or list of lists\n", + " Silent list of individual patches used to create the histogram\n", + " or list of such list if multiple input datasets.\n", + " \n", + " Other Parameters\n", + " ----------------\n", + " kwargs : `~matplotlib.patches.Patch` properties\n", + " \n", + " See also\n", + " --------\n", + " hist2d : 2D histograms\n", + " \n", + " Notes\n", + " -----\n", + " Until numpy release 1.5, the underlying numpy histogram function was\n", + " incorrect with `normed`=`True` if bin sizes were unequal. MPL\n", + " inherited that error. It is now corrected within MPL when using\n", + " earlier numpy versions.\n", + " \n", + " Examples\n", + " --------\n", + " .. plot:: mpl_examples/statistics/histogram_demo_features.py\n", + " \n", + " .. note::\n", + " In addition to the above described arguments, this function can take a\n", + " **data** keyword argument. If such a **data** argument is given, the\n", + " following arguments are replaced by **data[]**:\n", + " \n", + " * All arguments with the following names: 'weights', 'x'.\n", + "\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "help(plt.hist)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Matplotlib Example" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "values = [0,0.6,1.4,1.6,2.2,2.5,2.6,3.2,3.5,3.9,4.2,6]\n", + "plt.hist(values, bins = 3)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 5.3. Customization\n", + "\n", + "## Data Visualization\n", + "\n", + "- Science & Art\n", + "- Many options\n", + " - Different plot types\n", + " - Many customizations\n", + "- Choice depends on:\n", + " - Data\n", + " - Story you want to tell\n", + " \n", + "## Basic Plot" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "year = np.linspace(1950.,2100.,num=50)\n", + "\n", + "K = 11.;\n", + "P0 = 2.6;\n", + "r = 0.03;\n", + "population = K*P0*np.exp(r*(year-year[0])) / (K + P0*(np.exp(r*(year-year[0]))-1.))\n", + "\n", + "plt.plot(year, population)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Axis Labels, Title, Ticks, Axis Limits" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xd4HOW5/vHvY8uybEtyk7sty8YFXMDGAoMpIUCAUAIE\nQoAQSgCnXEno7RdIICfhAElIOHByEhIIhF5DCb2D6e69N9mWZcm2rGJLVnl+f+zYLIrlXQntjla6\nP9elS7uzszOPRpq9Ne878465OyIiInvTIewCRESk9VNYiIhITAoLERGJSWEhIiIxKSxERCQmhYWI\niMSksJAWY2bvmtkljbyWZ2ZuZmnJrqsxZnaUma37Cu//i5nd1JI1tTQzyzWzCjPrmArLldZLYdFO\nmNkNZvZKg2nLGpl2dnKrAzNbbWY7gg+gIjN7wMwyk11HY8zsQjObFj3N3X/k7v+VgHXdbGY1wbYo\nNbOPzOzQ5izL3de6e6a7133Fmlab2bEtvVxJHQqL9uN9YMqu/wTNbADQCZjYYNqIYN64WURL/C2d\n4u6ZwIFAPnBjCywzVT0RbIs+wDTgWTOzhjO1piM1adsUFu3H50TCYULw/AjgHWBJg2kr3H0DgJlN\nMbPPzWxb8H3KroUFTU6/NbMPge3A8OiVmVlHM/u9mZWY2UrgpHgLdff1wCvAuGBZA83sBTPbYmbL\nzezSqPXcbGZPm9kTZlZuZjPN7ICo193MRkQ9f8DMfrOn9ZrZ9Wa2IljOQjM7PZi+H/AX4NBd/+3v\naVlmdmlQ35ag3oEN6vhRcORWamb/u6cP/z1sixrgQaA/0Ds4wvnQzP5oZpuBm82sg5ndaGZrzGyT\nmf3TzLoH6/1S85+ZdTez+8ys0MzWm9lvopuSgp9hUdQ2ONDMHgJygReDn//aPSw31u/oyaCucjNb\nYGb5Ua9fF9RSbmZLzOyYWNtFkk9h0U64+07gU+DIYNKRwAdE/muNnvY+gJn1Al4C/gfoDdwJvGRm\nvaMW+31gKpAFrGmwykuBk4GJRI4Szoy3VjMbApwIzAomPQ6sAwYGy7nVzI6OesupwFNAL+BR4Dkz\n6xTv+qKsIBKY3YFbgIfNbIC7LwJ+BHwcNL302EPNRwP/DZwFDCCyPR5vMNvJwEHA/sF8x8cqyMw6\nAxcCBe5eEkyeDKwE+gG/DV6/EPg6kdDOBO5pZJEPALVEjiAnAscBlwTr+g5wM3A+kA18C9js7t8H\n1hIc+bn7HXtYbqzf0beCeXoAL+yqz8xGAz8FDnL3rGCbrI61XST5FBbty3t8EQxHEAmLDxpMey94\nfBKwzN0fcvdad38MWAycErW8B9x9QfB6TYN1nQX8yd0L3H0LkQ/SWJ4L/mufFtRxaxAchwHXuXuV\nu88G/k7kA22XGe7+dFDDnUAGcEgc6/sSd3/K3Te4e727PwEsAw6O8+3fA+5395nuXg3cQORIJC9q\nntvcvdTd1xI5qpvwn4vZ7axgWxQAk4DTo17b4O53B9t9R7DuO919pbtXBOs+u2ETlZn1IxLCl7t7\npbtvAv4I7OqjugS4w90/94jl7t7wn4D/EOfvaJq7vxz0cTwE7Dr6qwM6A2PMrJO7r3b3FbHWKcmn\nsGhf3gcOD44a+rj7MuAjIn0ZvYg0++zqrxjIfx4trAEGRT0v2Mu6BjZ4PeaHDnCau/dw96Hu/pPg\ng3AgsMXdy+Opw93r+eI/3CYxs/PNbHbQTFRKZHvkxPn2L22v4EN7c4M6N0Y93k7kCKAxTwbboq+7\nH+3uM6Jea7jdG/6u1gBpRI48og0l0hRZGPUz/hXoG7w+hMjRVVPF8ztq+LNnmFmauy8HLidyRLPJ\nzB6Pbr6T1kNh0b58TKSJ5VLgQwB3LwM2BNM2uPuqYN4NRD5couUC66Oe723I4kIiHz7R722ODUAv\nM8vaSx2712ORjvbBwfsg8sHUNWre/ntaiZkNBf5GpEmkd9DUNB/Y1a8Qa3jmL20vM+tGpPlufaPv\naL6GtTT8XeUSaWoqajBfAVAN5ARB1MPds919bNTr+8S5zobrj/U7apS7P+ruhwc/gwO3x/M+SS6F\nRTsS/Kc+HbiSSPPTLtOCadFnQb0MjDKzc80szcy+C4wB/h3n6p4Efm5mg82sJ3B9M2suIHL0899m\nlmFm+wMXAw9HzTbJzL4dNLtcTuQD8ZPgtdnAuRbpcD8B+Fojq+pG5IOqGMDMLiLoYA8UAYPNLL2R\n9z8GXGRmE4J+hluBT919ddN+4mZ5DLjCzIZZ5HTjW4mcTVUbPZO7FwKvA38ws+ygY3wfM9u1Tf4O\nXG1mkyxiRBCiEPn5v3QSQ9Ry4/kd7ZGZjTazo4NtVgXsAOqbugEk8RQW7c97RJodoq8Z+CCYtjss\n3H0zkQ7Zq4g0p1wLnBzVyRrL34DXgDnATODZr1DzOUAekf9g/wX8yt3fjHr9eeC7wFYine7fjupD\nuYxIP0spkbb95/a0AndfCPyByNFXETCe4Ogr8DawANhoZv+xDYJ6bgKeIXJUtQ9f9AUk2v1E+gHe\nB1YR+dD9WSPzng+kAwuJbK+niXTI4+5PEekwfxQoJ7KtegXv+2/gxqD56uo9LDfW76gxnYHbgBIi\nTVV9ifS5SCtjuvmRpDIzuxkY4e7nhV1La2Rmw4GlQCfXzi5fgY4sRNq2ccAaBYV8VQoLkTbKzK4E\n7qWZ/UUi0dQMJSIiMenIQkREYkqJQchycnI8Ly8v7DJERFLKjBkzSty9T0ssKyXCIi8vj+nTp4dd\nhohISjGzeEZOiIuaoUREJCaFhYiIxKSwEBGRmBQWIiISk8JCRERiSomzoURE5Mtq6uopKqsKvqp3\nf99UVkVReeRxS1JYiIi0MvX1TklFNetKd7Bh91cVG7dVUbhtB4XbqiiuqKbhABydOhp9szLol92Z\nkX0zeasFa1JYiIgkmbtTXFFNwZYdFGzZztot21m3dTvrS3ewfmskGHbWffm2Ht3SOzKgRxcGdM9g\ndP8sBnSPPO7fPYN+2ZGvnl07YWa73/OX77dczQoLEZEEqKt3NpTuYFVJJWs2V7KqZDtrNleydst2\nCrZup6rmy2HQJ6szg3t2Ydyg7hw/rj+DenSJfPXswsAeXcjO6BTSTxKhsBARaSZ3Z0vlTlaWVLJi\nUwUriitYWVzJqs2VFGzZTk3dF+1EXTp1ZGjvruTldOPIUX3I7dWVIb26kNurK4N7diWjU8cQf5LY\nFBYiIjG4OxvLqlhaVMGyonKWFpWzoriSFcUVlG6v2T1feloHhud0Y3S/LI4b059hOV0Z2rsbw3K6\n0Ter85eaiFKNwkJEJErp9p0sLCxjcWEkFJYWlbOsqILy6i9uaZ6Tmc4+fTI5cfwA9umTyfA+3RjR\nJ5OBPbrQsUPqBsLeKCxEpF2qr3dWba5kwYYyFheWsaiwjMUbyyncVrV7nl7d0hnZN5PTJg5iVL9M\nRvbLYlS/LHp1Sw+x8nAoLESkzautq2dlSSXz129j3vptLFhfxoIN26jcWQdAWgdjRN9MDhnem337\nZ7HfgGz2G5BNn6zOIVfeeigsRKRNcXfWbd3B7IJS5hSUMruglPkbtu0++6hLp46MGZjNmZMGM25Q\nd8YO7M6Ivpmkp2lAi71JWFiY2f3AycAmdx8XTOsFPAHkAauBs9x9a6JqEJG2r7K6ltkFpcxYs5U5\nBaXMWVdKScVOADqndWDcoO6cc3Au4wd1Z/yg7gzvk9lm+xUSKZFHFg8A9wD/jJp2PfCWu99mZtcH\nz69LYA0i0sZsKN3B9DVbmbF6CzPWbmVRYTl19Y4Z7NMnk6NG9+WAIT2YOKQHo/tn0amjjhhaQsLC\nwt3fN7O8BpNPBY4KHj8IvIvCQkQa4e6s2bydT1dt5pOVW/hs1RbWl+4AoGt6RyYM6cFPjtqHSUN7\nMjG3J927hHvhWluW7D6Lfu5eGDzeCPRrbEYzmwpMBcjNzU1CaSISNndnVUkln6zcEgTE5t0D4uVk\npjN5WG8uOWIY+UN7sd+ALNJ01JA0oXVwu7ubme/l9XuBewHy8/MbnU9EUltJRTUfLi/hw+UlTFtW\nwobg1NU+WZ05ZHhvJg/rxSHDe7NPn24pfVFbqkt2WBSZ2QB3LzSzAcCmJK9fREJWVVPHZ6u28MGy\nYqYt38yiwjIAsjPSOGxEDj/+eg6H7dObYTkKh9Yk2WHxAnABcFvw/fkkr19EQlCwZTvvLNnEu0uK\n+XjFZnbU1JHesQOThvbkmuNHc/iIHMYN6q6zlFqxRJ46+xiRzuwcM1sH/IpISDxpZhcDa4CzErV+\nEQlPTV09n63awtuLN/HOkk2sLK4EILdXV87KH8xRo/tyyPDedElv3YPnyRcSeTbUOY28dEyi1iki\n4SmvquHdJcW8uaiIdxZvoqyqlvS0DhwyvDfnTR7KUaP7qGkphekKbhFptqKyKl5fsJHXFxbxycrN\n1NQ5vbqlc9zY/nxjTD+OGJlD13R9zLQF+i2KSJMUbtvBK/M28vK8Qmas3Yo7DMvpxkWHDeMbY/px\nYG5P9T20QQoLEYlpfekOXplXyMvzCpm5thSAfftnccWxo/jmuP6M6Jup5qU2TmEhInu0uaKal+YV\n8vzsDcxYExnCbcyAbK45fjQnjOvPPn0yQ65QkklhISK7VVbX8sbCIp6bvZ4PlpVQV++M6pfJNceP\n5qTxA8jL6RZ2iRIShYVIO1dX70xbXsIzM9bxxsIidtTUMahHF6YeOZxTJwxk3/7ZYZcorYDCQqSd\nWlFcwTMz1vHszPVsLKuiR9dOnDFpEKdOGMSk3J50UCe1RFFYiLQjZVU1vDS3kKemFzBzbSkdOxhH\njerDr04Zw9H79aVzmi6Skz1TWIi0ce7OrIJSHvt0LS/O3UBVTT0j+2by/07cl9MmDKJvdkbYJUoK\nUFiItFFlVTU8N2s9j366lsUby+mW3pHTJw7m7IOGsP/g7jrVVZpEYSHSxswpKOXhT9bsPooYNyib\nW08fz7cmDCSzs3Z5aR795Yi0AdW1dbw8r5AHPlrDnIJSuqZ35PSJgzj34KGMH9w97PKkDVBYiKSw\norIqHvlkDY9+tpaSip0M79ONW741lm8fOIisDN1iVFqOwkIkBc1cu5X7p63i1fkbqXPn6NF9uWBK\nHoePyNEpr5IQCguRFFFX77yxcCN/+2AVM9ZsJTsjjQun5HH+oXnk9u4adnnSxiksRFq57TtreXrG\nOu6btoo1m7czpFcXbvnWWM6cNJhu6rCWJNFfmkgrVVxezT8/Xs1Dn6yhdHsNE3N7cP0J+3Lc2P4a\nAlySTmEh0sqs27qdv72/ksc/L2BnXT3HjenH1COHM2lor7BLk3ZMYSHSSizfVMFf3lvBc7PWYwbf\nnjiYH35tOMM1FLi0AgoLkZDNX7+NP7+7nFfmb6RzWge+f+hQLj1iOAN7dAm7NJHdFBYiIZm3bht3\nvbWUNxdtIqtzGj85ah8uOmwYOZmdwy5N5D8oLESSbP76bfzpzWW8uaiI7l06cdU3RnHBYXlk6yI6\nacUUFiJJsmBDJCTeWFhEdkYaV35jFBcqJCRFKCxEEmzJxnLufGMJry0oIisjjSuOHcVFhyskJLUo\nLEQSpGDLdv74xlL+NXs9melpXHbMSH5w+DC6d1FISOpRWIi0sOLyau55exmPfraWDmZcesRwfvy1\nfejZLT3s0kSaTWEh0kK27ajhb++v5L5pq9hZV89Z+UO47JiR9O+uO9FJ6lNYiHxFO2vreeiTNdz9\n9jJKt9dwygEDufIboxiW0y3s0kRajMJCpJncnVfmb+T2VxezZvN2Dh+Rw/Xf3Jdxg3SzIWl7FBYi\nzTBjzVZ++9JCZq4tZXS/LB646CC+NqqP7mstbZbCQqQJ1myu5PZXF/PyvI30yerM7WeM58xJQzQK\nrLR5oYSFmV0BXAI4MA+4yN2rwqhFJB4V1bXc8/Zy7p+2io4djMuPHcmlRwzX/SSk3Uj6X7qZDQJ+\nDoxx9x1m9iRwNvBAsmsRiaW+3nlm5jrueG0JxeXVnHHgYK49YTT9snWGk7QvYf1blAZ0MbMaoCuw\nIaQ6RBo1Y80WbnlxIXPXbWNibg/+dn4+E4b0CLsskVAkPSzcfb2Z/R5YC+wAXnf31xvOZ2ZTgakA\nubm5yS1S2rWN26r471cW8fzsDfTL7syfvjuBbx0wkA7ql5B2LIxmqJ7AqcAwoBR4yszOc/eHo+dz\n93uBewHy8/M92XVK+7Oztp5/fLiKu95aRm2987OjR/Cjr+2jfgkRwmmGOhZY5e7FAGb2LDAFeHiv\n7xJJoI9WlPDL5xewfFMFx+7Xj1+dMoYhvbqGXZZIqxFGWKwFDjGzrkSaoY4BpodQhwhFZVX89qVF\nvDBnA0N6deG+C/I5Zr9+YZcl0uqE0WfxqZk9DcwEaoFZBM1NIslSU1fPgx+t5o9vLKWm3vn5MSP5\nyVH7kNGpY9ilibRKoTTGuvuvgF+FsW6RmWu38v+encfijeUcNboPN58yljyN4ySyV+q5k3ajrKqG\nO15dzCOfrqVfVgZ/OW8Sx4/tpyE6ROKgsJA2z915ed5Gbn5xAZsrqrlwSh5XHTeaTJ3lJBI37S3S\nphVs2c4vn5/PO0uKGTcom/suyGf/wbqwTqSpFBbSJtXVO//4cBV/eH0pHQx+efIYzj90KGkdO4Rd\nmkhKUlhIm7OosIzrn5nLnHXbOHa/vvz61HEM7NEl7LJEUprCQtqM6to67nl7Of/37gq6d+nEPedO\n5KTxA9SBLdICFBbSJkxfvYXrnpnLiuJKvn3gIG46aQw9u6WHXZZIm6GwkJRWWV3LHa8u5p+frGFg\n9y48cNFBHDW6b9hlibQ5CgtJWR8tL+HaZ+ayvnQHFxyaxzXHj9agfyIJoj1LUk5FdS23vbKIhz9Z\ny7Ccbjz5w0M5KK9X2GWJtGkKC0kpHy4v4dqn57Jh2w4uOXwYVx03mi7pGs9JJNEUFpISKqprufXl\nRTz66VqG53Tj6R8dyqShOpoQSRaFhbR6H60o4ZqnIkcTlx4ROZrQ6LAiyaWwkFZrx846bn91MQ98\ntJphOpoQCZXCQlqlWWu3ctWTc1hZUsmFU/K49oTRdE3Xn6tIWLT3Sauys7aeu95ayv+9u4L+2Rk8\ncslkDhuRE3ZZIu2ewkJajUWFZVz55BwWFZbxnUmDuemUMWRndAq7LBFBYSGtQF298/cPVvKH15eS\n3aUTfzs/n2+M0X2wRVoThYWEat3W7Vz15Bw+XbWF48f249bTx9M7s3PYZYlIAwoLCYW78+zM9dz8\nwgIc+N2Z+3PmpMEaIVaklYorLMzsMOBmYGjwHgPc3YcnrjRpq7ZW7uQXz83j5XkbOSivJ3eeNYEh\nvbqGXZaI7EW8Rxb3AVcAM4C6xJUjbd17S4u55qk5bN2+k+tO2JepRw6nYwcdTYi0dvGGxTZ3fyWh\nlUibVlUTucDuHx+uZmTfTO6/8CDGDeoedlkiEqd4w+IdM/sd8CxQvWuiu89MSFXSpizeWMZlj81m\nSVE5F07J4/pv7qvhOkRSTLxhMTn4nh81zYGjW7YcaUvq650HPlrNba8uJjujE/+46CC+rhsTiaSk\nuMLC3b+e6EKkbdlUVsXVT8/l/aXFHLtfX247Y39ydEqsSMqK92yo7sCvgCODSe8Bv3b3bYkqTFLX\nmwuLuPaZuWzfWctvThvH9ybn6pRYkRQXbzPU/cB84Kzg+feBfwDfTkRRkpqqaur47UuLeOiTNYwd\nmM1dZ09kRN/MsMsSkRYQb1js4+5nRD2/xcxmJ6IgSU2LCsv4+WOzWLapgkuPGMbVx4+mc5o6sUXa\ninjDYoeZHe7u02D3RXo7EleWpAp358GPVnPrK5FO7H/+4GCOHNUn7LJEpIXFGxY/Bh4M+i4M2AJc\n2NyVmlkP4O/AOCJnVf3A3T9u7vIkHCUV1Vzz1BzeWVLM0fv25Y4z1Ykt0lbFezbUbOAAM8sOnpd9\nxfXeBbzq7meaWTqgsR5SzPtLi7nyyTmUVdVw8yljuGBKnjqxRdqwvYaFmZ3n7g+b2ZUNpgPg7nc2\ndYXB0cmRBEcm7r4T2NnU5Ug4dtbW84fXl/DX91cysm8mD118MPsNyA67LBFJsFhHFt2C71l7eM2b\nuc5hQDHwDzM7gMh4U5e5e2X0TGY2FZgKkJub28xVSUtaXVLJzx+fxdx12/je5FxuPGkMXdLViS3S\nHph77M98MzvM3T+MNS2uFZrlA58Ah7n7p2Z2F1Dm7jc19p78/HyfPn16U1clLejZmeu46bn5pHXs\nwO1njOeEcQPCLklEYjCzGe6eH3vO2DrEOd/dcU6Lxzpgnbt/Gjx/GjiwmcuSBCuvquGKJ2Zz5ZNz\nGDuwOy9fdoSCQqQditVncSgwBejToN8iG2hW+4O7bzSzAjMb7e5LgGOAhc1ZliTWnIJSfv74LAq2\nbOfyY0fy06+PIK1jvP9fiEhbEqvPIh3IDOaL7rcoA878Cuv9GfBIcCbUSuCir7AsaWH19c7fp63k\njleX0DerM49PPZSDh/UKuywRCdFew8Ld3wPeM7MH3H1NS600OBW3RdrRpGUVl1dz1VNzeH9pMceP\n7cftZ+xPj67pYZclIiGL96K87cH9LMYCGbsmuruGKG9DPlhWzBVPzKG8qkYDAIrIl8QbFo8ATwAn\nAz8CLiBy+qu0ATV19fz+9SX89b3ItROPXDKZ0f33dLa0iLRX8YZFb3e/z8wui2qa+jyRhUlyFGzZ\nzs8em8XsglLOnZzLTbp2QkT2IN6wqAm+F5rZScAGQD2eKe6FORv4xbPzwODP3zuQE8frlFgR2bN4\nw+I3wTAdVxG5viIbuCJhVUlCbd9Zy80vLODJ6euYNLQnd509gcE9NTyXiDQu3oEE/x083AboFqsp\nbFFhGT99dCYrSyr56ddHcPmxI3XthIjEFOuivLvZyxhQ7v7zFq9IEsLdeeiTNfzmpUX06NKJRy6e\nzJQROWGXJSIpItaRhQZkagO2Vu7k2mfm8sbCIr4+ug+//84B9NZ9J0SkCWJdlPdgsgqRxPhk5Wau\neGI2JRXV3HjSflx8+DBdOyEiTRZXn4WZvcMemqN0UV7rVVtXz/+8vZx73l7G0N7d+NdPDmPcoO5h\nlyUiKSres6GujnqcAZwB1LZ8OdIS1pfu4PLHZ/H56q2cceBgfn3qWLp1jvdXLSLyn+I9G2pGg0kf\nmtlnCahHvqJX5hVy3TNzqXf403cncNrEQWGXJCJtQLzNUNEX4HUAJgFq02hFduys479eWsijn65l\n/8HdufuciQzt3S32G0VE4hBv28QMIn0WRqT5aRVwcaKKkqZZVFjGzx+bxbJNFfzwyOFcddxo0tN0\n7YSItJx4m6GGJboQaTp358GPVnPrK4vp3qUTD118MEeM7BN2WSLSBsXbDJUB/AQ4nMgRxgfAX9y9\nKoG1yV5srqjm2qfn8tbiTRy9b19+d+b+unZCRBIm3maofwLlfHHf7XOBh4DvJKIo2btpy0q48snZ\nlO6o4eZTxnDBlDxdOyEiCRVvWIxz9zFRz98xM903O8l21tbzh9eX8Nf3VzKibyYP/uBg9huQHXZZ\nItIOxBsWM83sEHf/BMDMJqOhQJJqRXEFlz0+i/nry3TfCRFJunjDYhLwkZmtDZ7nAkvMbB7g7r5/\nQqoT3J3HPy/g1y8uJKNTB/76/UkcP7Z/2GWJSDsTb1ickNAqZI+2Vu7k+mfn8tqCIg4b0Zs7z5pA\nv+yM2G8UEWlh8Z46u8bMDgCOCCZ94O5zEleWfLg80om9pXInvzgxMgBghw7qxBaRcMR15ZaZXQY8\nAvQNvh42s58lsrD2qrq2jltfXsR5931KZuc0/vWTw7j0yOEKChEJVbzNUBcDk929EsDMbgc+5otT\naaUFLNlYzmWPz2LxxnK+NzmXG9WJLSKtRLxhYUBd1PO6YJq0gPp654GPVnPbq4vJzkjj/gvzOXrf\nfmGXJSKyW7xh8Q/gUzP7V/D8NOC+xJTUvhSVVXH1U3P4YFkJx+7Xl9vO2J8cXYktIq1MvB3cd5rZ\nu0SG+wC4yN1nJayqduKVeYXc8K95VNfUc+vp4znn4CG6EltEWqW9hkUwJtSPgBHAPODP7q6bHn1F\nZVU13Pz8Ap6dtZ4DBnfnj9+dwPA+mWGXJSLSqFhHFg8CNUQGDvwmsB9weaKLass+Wl7C1U/Noai8\nmsuOGclPjx5Bp44aTlxEWrdYYTHG3ccDmNl9gO6O10xVNXXc/upi/vHhaobndOOZH09hwpAeYZcl\nIhKXWGFRs+uBu9eqPb155q4r5YonZrOiuJILp+Rx3Qn76pRYEUkpscLiADMrCx4b0CV4bkTGhGr2\nkKdm1pHIYITr3f3k5i6nNaupq+fP76zg7reX0SerMw9fPJnDR+aEXZaISJPtNSzcPZH//l4GLALa\n5BjbSzaWc9VTs5m/vozTJgzkllPH0b1Lp7DLEhFplnivs2hRZjYYOAn4LXBlGDUkSm1dPX99fyV3\nvbmMrIw0/nLegZwwbkDYZYmIfCWhhAXwJ+BaIKuxGcxsKjAVIDc3N0llfTXLN5Vz1VNzmVNQyknj\nB/DrU8fqVqci0iYkPSzM7GRgk7vPMLOjGpvP3e8F7gXIz8/3JJXXLHX1zn3TVvL715fSLb0j95w7\nkZP3Hxh2WSIiLSaMI4vDgG+Z2YlABpBtZg+7+3kh1PKVLd9UwbVPz2Hm2lKOG9OP354+nj5ZOpoQ\nkbYl6WHh7jcANwAERxZXp2JQ7O6beGsZXdM78sfvHsBpEwZpuA4RaZPC6rNIaQs3lHHtM3OYv76M\nE8f355ZvjdPRhIi0aaGGhbu/C7wbZg1NUV1bx/++vZw/v7uCHl078X/fO5BvjteZTiLS9unIIk6z\nC0q59uk5LC2q4NsTB3HTyWPo2S097LJERJJCYRFDRXUtv39tCQ9+vJp+WRm6MZGItEsKi714a1ER\nNz03n8KyKr5/yFCuOX40WRm6CltE2h+FxR5sKqvilhcX8tK8Qkb1y+Tpc6cwaWjPsMsSEQmNwiJK\nfb3zxPQCbn15EdW19Vx93CimHrkP6Wm634SItG8Ki8DijWXc+K/5TF+zlUOG9+LW08fr7nUiIoF2\nHxaV1bWJPhB9AAAKjElEQVTc9dYy7pu2iuyMNO44c3++M2mwLq4TEYnSbsPC3XltwUZueXEhhduq\nOPugIVx3wr46HVZEZA/aZVgUbNnOL5+fzztLitm3fxZ3nzOR/LxeYZclItJqtauwqKqp46/vreTP\n7y6nYwfjxpP244IpeXTqqA5sEZG9aRdh4e68vrCI//r3QtZt3cGJ4/tz40ljGNijS9iliYikhDYf\nFss3VXDLiwv4YFkJo/pl8uglk5kyQvfBFhFpijYbFuVVNdz99nLun7aKLukd+dUpYzjvkKFqchIR\naYY2FxZ19c4zM9bxu9eXUFJRzVmThnDNCaPJ0e1NRUSarU2FxUcrSvjNvxexsLCMibk9+Pv5+Rww\npEfYZYmIpLw2ERarSiq59eVFvLGwiEE9unD3ORM5ef8BurBORKSFpHRYbNtew11vLeOfH6+mc1oH\nrjl+NBcfPoyMTh3DLk1EpE1JybCoqqnjoY/XcM87yymrquG7+UO48rhR9M3KCLs0EZE2KaXCoq7e\neW7Weu58YynrS3fwtVF9uO6EfRkzMDvs0kRE2rSUCYt3Fm/i9lcXs3hjOeMHded3Z+6v6yVERJIk\nJcJiZXElFz3wOUN7d+XucyZy0vgBdOigzmsRkWRJibCorq3j16eO5eyDcnUjIhGREKREWIzun8X5\nh+aFXYaISLuVEv+md9D1EiIioUqJsBARkXApLEREJCaFhYiIxKSwEBGRmBQWIiISk8JCRERiSnpY\nmNkQM3vHzBaa2QIzuyzZNYiISNOEcVFeLXCVu880syxghpm94e4LQ6hFRETikPQjC3cvdPeZweNy\nYBEwKNl1iIhI/ELtszCzPGAi8OkeXptqZtPNbHpxcXGySxMRkSihhYWZZQLPAJe7e1nD1939XnfP\nd/f8Pn36JL9AERHZLZSwMLNORILiEXd/NowaREQkfmGcDWXAfcAid78z2esXEZGmC+PI4jDg+8DR\nZjY7+DoxhDpERCROST911t2nARpzXEQkhegKbhERiUlhISIiMSksREQkJoWFiIjEpLAQEZGYFBYi\nIhKTwkJERGJSWIiISEwKCxERiUlhISIiMSksREQkJoWFiIjEpLAQEZGYFBYiIhKTwkJERGJSWIiI\nSEwKCxERiUlhISIiMSksREQkJoWFiIjEpLAQEZGYFBYiIhKTwkJERGJSWIiISEwKCxERiUlhISIi\nMSksREQkJoWFiIjEpLAQEZGYFBYiIhKTwkJERGIKJSzM7AQzW2Jmy83s+jBqEBGR+CU9LMysI/C/\nwDeBMcA5ZjYm2XWIiEj8wjiyOBhY7u4r3X0n8Dhwagh1iIhInNJCWOcgoCDq+TpgcsOZzGwqMDV4\nWmFmSxJQSw5QkoDlJpJqTrxUqxdSr+ZUqxdSs+bRLbWgMMIiLu5+L3BvItdhZtPdPT+R62hpqjnx\nUq1eSL2aU61eSN2aW2pZYTRDrQeGRD0fHEwTEZFWKoyw+BwYaWbDzCwdOBt4IYQ6REQkTklvhnL3\nWjP7KfAa0BG4390XJLuOQEKbuRJENSdeqtULqVdzqtUL7bxmc/eWWpaIiLRRuoJbRERiUliIiEhM\nbS4szOx+M9tkZvOjph1gZh+b2Twze9HMsqNe2z94bUHwekYwfVLwfLmZ/Y+ZWdj1mlknM3swmL7I\nzG6Iek9S6g3WNcTM3jGzhcF2uyyY3svM3jCzZcH3nlHvuSGobYmZHZ/Muptar5l9w8xmBHXNMLOj\nk1lvc2qOel+umVWY2dXJrLmZfxNh73tN/bsIff/bS83fCZ7Xm1l+g/e0zL7n7m3qCzgSOBCYHzXt\nc+BrweMfAP8VPE4D5gIHBM97Ax2Dx58BhwAGvAJ8sxXUey7wePC4K7AayEtmvcG6BgAHBo+zgKVE\nhm65A7g+mH49cHvweAwwB+gMDANWJHM7N6PeicDA4PE4YH3UspL1d9GkmqPe9zTwFHB1MmtuxjZu\nDfteU2sOff/bS837EbkA710gP2r+Ftv3WvyHaQ1fQB5f/vDdxhed+UOAhcHjE4GHG/mFLI56fg7w\n11ZQ7znAi8GO1jv4Q+mV7Hr3UP/zwDeAJcCAqG24JHh8A3BD1PyvAYeGVXesehvMa8CWYGcLbTvH\nUzNwGvA74GaCsGit27i17HtNrLnV7X+7ao56/i5fDosW2/faXDNUIxbwxfhT3+GLiwJHAW5mr5nZ\nTDO7Npg+iMgwJLusC6YlS2P1Pg1UAoXAWuD37r6FEOs1szwi/4l/CvRz98LgpY1Av+DxnoZ4GUQI\ndcdZb7QzgJnuXk1I2zmems0sE7gOuKXB21vrNm5V+16cNbeq/a9BzY1psX2vvYTFD4CfmNkMIodu\nO4PpacDhwPeC76eb2THhlPgljdV7MFAHDCRySHmVmQ0Pp8TdH1DPAJe7e1n0ax75d6VVnZfd1HrN\nbCxwO/DDpBXZQBNqvhn4o7tXJLfCL2tCva1m32tCza1m/9tbzYnSaseGaknuvhg4DsDMRgEnBS+t\nA95395LgtZeJ9B88TGQYkl2SOiTJXuo9F3jV3WuATWb2IZAPfJDses2sE5E/1kfc/dlgcpGZDXD3\nQjMbAGwKpjc2xMv6ZNXdxHoxs8HAv4Dz3X1F1M+RtO3cxJonA2ea2R1AD6DezKqC97fGbdwq9r0m\n1twq9r9Gam5Mi+177eLIwsz6Bt87ADcCfwleeg0Yb2ZdzSwN+BqR/oFCoMzMDgnOEDifSNtg2PWu\nBY4OXutGpHNqcbLrDdZxH7DI3e+MeukF4ILg8QVRNbwAnG1mnc1sGDAS+CxZdTe1XjPrAbxEpJPz\nw10zJ3M7N7Vmdz/C3fPcPQ/4E3Cru9/TWrcxrWDfa0bNoe9/e6m5MS237yWjEyaZX8BjRNoUa4j8\n93IxcBmRzqilwG0EncfB/OcR6SOYD9wRNT0/mLYCuCf6PWHVC2QSOdNlAbAQuCbZ9QbrOpzIoflc\nYHbwdSKRTr+3gGXAm0CvqPf8IqhtCVFnXSSj7qbWSySgK6PmnQ30TfLfRZO3cdR7b+bLZ0O1um3c\nSva9pv5dhL7/7aXm04l8flQDRcBrLb3vabgPERGJqV00Q4mIyFejsBARkZgUFiIiEpPCQkREYlJY\niIhITAoLkQYsYpqZfTNq2nfM7NUw6xIJk06dFdkDMxtH5Jz6iURGOpgFnOBfXM3dnGWmuXttC5Uo\nklQ6shDZA3efT2SE0euAXwL/dPcVZnaBmX1mZrPN7M/BVfaY2b1mNt0i9xT45a7lmNk6M7vNzGYR\nuXBKJCW1i7GhRJrpFmAmkYEc84OjjdOBKe5ea2b3AmcDjxIZGmRLMHTFO2b2tLsvDJazyd0nhvED\niLQUhYVII9y90syeACrcvdrMjgUOAqZHhtOhC18M/3yOmV1MZJ8aSOSmM7vC4onkVi7S8hQWIntX\nH3xB5EZI97v7TdEzmNlIIuN5HezupWb2MJARNUtlUioVSSD1WYjE703gLDPLATCz3maWC2QD5URG\n8RwAHL+XZYikJB1ZiMTJ3eeZ2S3Am0HHdg3wI2A6kSanxcAa4MPGlyKSmnTqrIiIxKRmKBERiUlh\nISIiMSksREQkJoWFiIjEpLAQEZGYFBYiIhKTwkJERGL6/7gwG3hogS4bAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(year, population)\n", + "\n", + "plt.xlabel('Year')\n", + "plt.ylabel('Population')\n", + "plt.title('World Population Projections')\n", + "plt.yticks([0,2,4,6,8,10])\n", + "plt.xlim(1950, 2100)\n", + "plt.ylim(0, 11)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tick Labels" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEWCAYAAABMoxE0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(year, population)\n", + "\n", + "plt.xlabel('Year')\n", + "plt.ylabel('Population')\n", + "plt.title('World Population Projections')\n", + "plt.yticks([0,2,4,6,8,10],['0','2B','4B','6B','8B','10B'])\n", + "plt.xlim(1950, 2100)\n", + "plt.ylim(0, 11)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Add Historical Data" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEWCAYAAABMoxE0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "population = [1.0,1.262,1.650] + population.tolist()\n", + "year = [1800,1850,1900] + year.tolist()\n", + "\n", + "plt.fill_between(year, population, 0, color='green')\n", + "\n", + "plt.xlabel('Year')\n", + "plt.ylabel('Population')\n", + "plt.title('World Population Projections')\n", + "plt.yticks([0,2,4,6,8,10],['0','2B','4B','6B','8B','10B'])\n", + "plt.xlim(1800, 2100)\n", + "plt.ylim(0, 11)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 6.1. Boolean Logic & Control Flow\n", + "\n", + "## Booleans\n" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 < 3" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 == 3" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = 2\n", + "y = 3\n", + "x < y" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x == y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Relational Operators\n", + "\n", + "| operator | meaning |\n", + "| :---: | --- |\n", + "| < | strictly less than |\n", + "| <= | less than or equal |\n", + "| > | strictly greater than |\n", + "| >= | greater than or equal |\n", + "| == | equal |\n", + "| != | not equal |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Logical Operators\n", + "\n", + "- and\n", + "- or\n", + "- not" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "False\n", + "False\n" + ] + } + ], + "source": [ + "print(True and True)\n", + "print(True and False)\n", + "print(False and True)\n", + "print(False and False)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n", + "True\n", + "False\n" + ] + } + ], + "source": [ + "print(True or True)\n", + "print(True or False)\n", + "print(False or True)\n", + "print(False or False)" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "True\n" + ] + } + ], + "source": [ + "print(not True)\n", + "print(not False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conditional Statements\n", + "\n", + "```python\n", + "if condition :\n", + " expression\n", + "```\n", + "Note the indentation of expression and the colon after the condition." + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "z is even\n" + ] + } + ], + "source": [ + "z = 4\n", + "if z % 2 == 0 :\n", + " print(\"z is even\")" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "z is odd\n" + ] + } + ], + "source": [ + "z = 5\n", + "if z % 2 == 0 :\n", + " print(\"z is even\")\n", + "else :\n", + " print(\"z is odd\")" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "z is divisible by 3\n" + ] + } + ], + "source": [ + "z = 3\n", + "if z % 2 == 0 :\n", + " print(\"z is divisible by 2\")\n", + "elif z % 3 == 0 :\n", + " print(\"z is divisible by 3\")\n", + "else :\n", + " print(\"z is neither divisible by 2 nor by 3\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 6.2. Pandas\n", + "\n", + "## Overview\n", + "\n", + "- Huge amounts of data are common\n", + "- 2D Numpy array?\n", + " - Only one type possible\n", + "- Pandas\n", + " - High-level data manipulation\n", + " - DataFrame\n", + " \n", + "## CSV file $\\rightarrow$ DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0countrypopulationareacapital
0BRBrazil2008515767Brasilia
1RURussia14417098242Moscow
2INIndia12523287590New Delhi
3CHChina13579596961Beijing
4SASouth Africa551221037Pretoria
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 country population area capital\n", + "0 BR Brazil 200 8515767 Brasilia\n", + "1 RU Russia 144 17098242 Moscow\n", + "2 IN India 1252 3287590 New Delhi\n", + "3 CH China 1357 9596961 Beijing\n", + "4 SA South Africa 55 1221037 Pretoria" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "brics = pd.read_csv(\"brics.csv\")\n", + "brics" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countrypopulationareacapital
BRBrazil2008515767Brasilia
RURussia14417098242Moscow
INIndia12523287590New Delhi
CHChina13579596961Beijing
SASouth Africa551221037Pretoria
\n", + "
" + ], + "text/plain": [ + " country population area capital\n", + "BR Brazil 200 8515767 Brasilia\n", + "RU Russia 144 17098242 Moscow\n", + "IN India 1252 3287590 New Delhi\n", + "CH China 1357 9596961 Beijing\n", + "SA South Africa 55 1221037 Pretoria" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "brics = pd.read_csv(\"brics.csv\", index_col = 0)\n", + "brics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Column access" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "BR Brazil\n", + "RU Russia\n", + "IN India\n", + "CH China\n", + "SA South Africa\n", + "Name: country, dtype: object" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "brics[\"country\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "BR Brazil\n", + "RU Russia\n", + "IN India\n", + "CH China\n", + "SA South Africa\n", + "Name: country, dtype: object" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "brics.country" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Add Column" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countrypopulationareacapitalon_earth
BRBrazil2008515767BrasiliaTrue
RURussia14417098242MoscowTrue
INIndia12523287590New DelhiTrue
CHChina13579596961BeijingTrue
SASouth Africa551221037PretoriaTrue
\n", + "
" + ], + "text/plain": [ + " country population area capital on_earth\n", + "BR Brazil 200 8515767 Brasilia True\n", + "RU Russia 144 17098242 Moscow True\n", + "IN India 1252 3287590 New Delhi True\n", + "CH China 1357 9596961 Beijing True\n", + "SA South Africa 55 1221037 Pretoria True" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "brics[\"on_earth\"] = [True, True, True, True, True]\n", + "brics" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countrypopulationareacapitalon_earthdensity
BRBrazil2008515767BrasiliaTrue23.485847
RURussia14417098242MoscowTrue8.421918
INIndia12523287590New DelhiTrue380.826076
CHChina13579596961BeijingTrue141.398928
SASouth Africa551221037PretoriaTrue45.043680
\n", + "
" + ], + "text/plain": [ + " country population area capital on_earth density\n", + "BR Brazil 200 8515767 Brasilia True 23.485847\n", + "RU Russia 144 17098242 Moscow True 8.421918\n", + "IN India 1252 3287590 New Delhi True 380.826076\n", + "CH China 1357 9596961 Beijing True 141.398928\n", + "SA South Africa 55 1221037 Pretoria True 45.043680" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "brics[\"density\"] = brics[\"population\"] / brics[\"area\"] * 1000000\n", + "brics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Row access" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "country Brazil\n", + "population 200\n", + "area 8515767\n", + "capital Brasilia\n", + "on_earth True\n", + "density 23.4858\n", + "Name: BR, dtype: object" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "brics.loc[\"BR\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Element access" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Beijing'" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "brics.loc[\"CH\",\"capital\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Beijing'" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "brics[\"capital\"].loc[\"CH\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Beijing'" + ] + }, + "execution_count": 105, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "brics.loc[\"CH\"][\"capital\"]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/README.md b/README.md index 6cde40a..794bb81 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,4 @@ -# PythonTutorial +# Python Tutorial From Microsoft's FREE Edx course + +This is for personal use only. The repo will be deleted in 48 hours.