Introduction to Python - Part A.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SSDA Training Workshop I.1.D: Introduction to Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This script is developed for the use of SSDA training workshop ONLY! (and CHI Python Workshop (unofficially))\n",
    "# Please contact ssda@msu.edu if you have any questions.\n",
    "# This script is updated on November 10, 2019. V2019-1.0\n",
    "\n",
    "## This script was entirely borrowed from the SSDA introductory workshop to Python\n",
    "# I heavily reccomend checking out SSDA workshops when the pandemic subsides. \n",
    "# https://ssda.msu.edu/\n",
    "# datacamp.com is also a good source to learn Python and other data science tools\n",
    "# SSDA provides free access to datacamp if you respond to this google form: \n",
    "# https://docs.google.com/forms/d/e/1FAIpQLSfWDHfLglnSCFQmHlXzb98LfCr6oVWQQ1gdQM9hYGoFNRUnhw/viewform?vc=0&c=0&w=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table of Contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Part A\n",
    "\n",
    "## 1 Python Basics\n",
    "### 1.1 \"Hello, World!\"\n",
    "### 1.2 Python as a calculator\n",
    "### 1.3 Python variable assignment\n",
    "### 1.4 Pytohn variable types\n",
    "\n",
    "## 2 Python Lists\n",
    "### 2.1 Create a Python list\n",
    "### 2.2 Select from a Python list\n",
    "\n",
    "## 3 Python Functions & Packages\n",
    "### 3.1 Python fuctions\n",
    "### 3.2 Python methods\n",
    "### 3.3 Python packages\n",
    "\n",
    "## 4 Data Structure\n",
    "### 4.1 Dcitinary\n",
    "### 4.2 Pandas\n",
    "\n",
    "# Part B\n",
    "\n",
    "## 5 Visulizatoin using Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 Python Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 \"Hello, World!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A \"Hello, World!\" program generally is a computer program that\n",
    "# outputs or displays the message \"Hello, World!\".\n",
    "# Such a program is very simple in most programming languages,\n",
    "# and is often used to illustrate the basic syntax of\n",
    "# a programming language. It is often the first program written\n",
    "# by people learning to code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, Python!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The print() function in Python is a function\n",
    "# that outputs whatever you say you want to print out.\n",
    "help(print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# help is also a useful function that let's you know what a function is all about\n",
    "help(help)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Python as a calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Addition, subtraction\n",
    "print(5 + 5)\n",
    "print(5 - 5)\n",
    "\n",
    "# Multiplication, division\n",
    "print(3 * 5)\n",
    "print(10 / 2)\n",
    "\n",
    "# modulo, and exponentiation\n",
    "print(18 % 7)\n",
    "print(4 ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Suppose you have $100, which you can invest with a 10% return\n",
    "# each year.  Calculate how much money you end up with after\n",
    "# 7 years."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(100*1.1**7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.3 Python Variable Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOTE: Python variables are CASE-SENSITIVE!\n",
    "\n",
    "# Create a variable savings\n",
    "savings = 100\n",
    "\n",
    "# Create a variable growth_factor\n",
    "growth_factor = 0.1\n",
    "\n",
    "# Create a variable year\n",
    "year = 7\n",
    "\n",
    "# Calculate result\n",
    "result = savings * (1 + growth_factor) ** year\n",
    "\n",
    "# Print out result\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.4 Python Variable Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# int: integer number\n",
    "# float: real number\n",
    "# str: string, text\n",
    "# bool: boolean - True or False\n",
    "# type() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(savings))\n",
    "print(type(growth_factor))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "profitable = True\n",
    "print(type(profitable))\n",
    "feeling = \"Awesome!\"\n",
    "print(type(feeling))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python variable type conversion\n",
    "# str() int() float() bool()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(savings)\n",
    "print(type(savings))\n",
    "savings_now = str(savings)\n",
    "print(savings_now)\n",
    "print(type(savings_now))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Suppose you have $100, which you can invest with a 10% return\n",
    "# each year.  Calculate how much money you end up with after\n",
    "# 7 years. Please print out \"I started with $100 and now after\n",
    "# 7 years I have almost $195. Awesome!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings = 100\n",
    "growth_factor = 0.1\n",
    "years = 7\n",
    "result = savings * (1 + growth_factor) ** years\n",
    "# print(\"I started with $\" + savings + \" and now after \"\n",
    "#      + years + \" years I have almost $\" + \n",
    "#      result + \". Awesome!\")\n",
    "print(\"I started with $\" + str(savings) + \" and now after \"\n",
    "      + str(years) + \" years I have almost $\" + \n",
    "      str(round(result)) + \". Awesome!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 Python Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python Variable Types - type()\n",
    "# 1. int: integer number\n",
    "# 2. float: real number\n",
    "# 3. str: string, text\n",
    "# 4. bool: boolean - True or False\n",
    "# 5. list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Creat a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Banks = [\"Citi\", \"Goldman Sachs\", \"American Express\", \"HSBC\", \"Discover\"]\n",
    "APY = [0.0221, 0.02, 0.019, 0.022, 0.019]\n",
    "Bank_APY = [[\"Citi\", \"2.21%\"], [\"Goldman Sachs\", \"2%\"], [\"American Express\", \"1.9%\"], \n",
    "       [\"HSBC\", \"2.2%\"], [\"Discover\", \"1.9%\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Select from a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1 Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !!! ZERO BASED INDEXING !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To select HSBC Bank\n",
    "print(Banks[3])\n",
    "print(Bank_APY[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Negative Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To select HSBC Bank\n",
    "print(Banks[-2])\n",
    "print(Bank_APY[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2 Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. list[start:end] where start is incluvise and end is exclusive\n",
    "# 2. list[:end] or list[start:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(Banks))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Banks[2:4])\n",
    "print(Banks[2:])\n",
    "print(Banks[:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Suppose you have $100, which you can deposit into your saving account at Discover Bank.\n",
    "# Calculate how much money you end up with after\n",
    "# 10 years."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings = 100\n",
    "bank = Banks[-1]\n",
    "growth_factor = APY[-1]\n",
    "years = 10\n",
    "result = savings * (1 + growth_factor) ** years\n",
    "print(\"I started with $\" + str(savings) + \" and now after \"\n",
    "      + str(years) + \" years I have almost $\" + \n",
    "      str(round(result)) + \" in my \" + bank + \" saving account. Awesome!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 Python Functions & Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Python Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What is a python function?\n",
    "# Resuable code which sloves a particular task.\n",
    "# Built-in Functions:\n",
    "# max(): maximum of a list\n",
    "# len(): length of a list\n",
    "# type(); print(); str(); float(); int(); bool(); round(); sorted(); help(), etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(max(APY))\n",
    "print(max(Banks))\n",
    "print(max(Bank_APY))\n",
    "help(sorted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(APY))\n",
    "print(sorted(Banks, reverse=True))\n",
    "print(sorted(Bank_APY))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.2 Python Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To call functions on objects/variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.1 String methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# str.capitalize(); str.replace(); str.upper(); str.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Banks[0])\n",
    "print(Banks[0].upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.2 List methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list.index(); list.count(); list.append(); list.remove(), etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Banks = [\"Citi\", \"Goldman Sachs\", \"American Express\", \"HSBC\", \"Discover\"]\n",
    "APY = [0.0221, 0.02, 0.019, 0.022, 0.019]\n",
    "\n",
    "print(APY.index(max(APY)))\n",
    "print(Banks[APY.index(max(APY))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Suppose you have $100, and you would like to deposit it into a saving account\n",
    "# which has the highest APY.\n",
    "# Calculate how much money you end up with after\n",
    "# 10 years."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings = 100\n",
    "Banks = [\"Citi\", \"Goldman Sachs\", \"American Express\", \"HSBC\", \"Discover\"]\n",
    "APY = [0.0221, 0.02, 0.019, 0.022, 0.019]\n",
    "growth_factor = max(APY)\n",
    "bank = Banks[APY.index(max(APY))]\n",
    "years = 10\n",
    "result = savings * (1 + growth_factor) ** years\n",
    "print(\"I started with $\" + str(savings) + \" and now after \"\n",
    "      + str(years) + \" years I have almost $\" + \n",
    "      str(round(result)) + \" in my saving account at \" + bank + \"bank. Awesome!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 Python Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q: What are Python packages?\n",
    "# A: Python package is like a directory of Python scripts.\n",
    "# Each script is a module in the package.\n",
    "# Each module is imported to solve a specific problem\n",
    "# with specific functions, methods and types.\n",
    "# Thousands of Python packages available, i.e.\n",
    "# Numpy, Pandas, Matplotlib\n",
    "# Not all the packages are installed by default.\n",
    "# Install package --> import package"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# How big is Earth - Equatorial circumference of the Earth\n",
    "\n",
    "# Earth/radius (r) in [km]\n",
    "r = 6378\n",
    "\n",
    "# Import the math package\n",
    "import math\n",
    "\n",
    "# Earth/equatorial circumference (C)\n",
    "C = 2 * math.pi * r\n",
    "\n",
    "# Build printout\n",
    "print(\"The equatorial circumference of the Earth is \" + str(round(C)) + \" km.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.1 NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q: Why do we need the NumPy package?\n",
    "savings = 100\n",
    "Banks = [\"Citi\", \"Goldman Sachs\", \"American Express\", \"HSBC\", \"Discover\"]\n",
    "APY = [0.0221, 0.02, 0.019, 0.022, 0.019]\n",
    "years = 10\n",
    "result = savings * (1 + APY) ** years\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q: What is NumPy?\n",
    "# A: A Python packege - Numerical Python\n",
    "# NumPy Array: an alternative to Python list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the NumPy package\n",
    "import numpy as np\n",
    "\n",
    "savings = 100\n",
    "Banks = [\"Citi\", \"Goldman Sachs\", \"American Express\", \"HSBC\", \"Discover\"]\n",
    "APY = [0.0221, 0.02, 0.019, 0.022, 0.019]\n",
    "\n",
    "# Convert APY, a Python list, to np_APY, an NumPy array\n",
    "np_APY = np.array(APY)\n",
    "\n",
    "years = 10\n",
    "result = savings * (1 + np_APY) ** years\n",
    "print(np.round(result))\n",
    "print(Banks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOTE: Python list can contain ANY type\n",
    "#       but NumPy array contains ONE type\n",
    "\n",
    "import numpy as np\n",
    "unbelievable = [\"SSDA workshop\", 28, True]\n",
    "np_unbelievable = np.array(unbelievable)\n",
    "print(np_unbelievable)\n",
    "print(type(np_unbelievable))\n",
    "\n",
    "# Type Coercion:\n",
    "#       str, float, int, bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOTE: Python list and NumPy array behave differently!\n",
    "APY = [0.0221, 0.02, 0.019, 0.022, 0.019]\n",
    "\n",
    "import numpy as np\n",
    "np_APY = np.array(APY)\n",
    "\n",
    "print(APY + APY)\n",
    "print(np_APY + np_APY)\n",
    "\n",
    "print(type(APY))\n",
    "print(type(np_APY))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.1.1 NumPy Array Subsetting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the banks whoes APY is higher than 0.02\n",
    "Banks = [\"Citi\", \"Goldman Sachs\", \"American Express\", \"HSBC\", \"Discover\"]\n",
    "APY = [0.0221, 0.02, 0.019, 0.022, 0.019]\n",
    "print(APY > 0.02)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the banks whoes APY is higher than 0.02\n",
    "import numpy as np\n",
    "np_APY = np.array(APY)\n",
    "np_Banks = np.array(Banks)\n",
    "print(np_APY>0.02)\n",
    "print(np_Banks[np_APY>0.02])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.1.2 2D NumPy Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Bank_APY = [[\"Citi\", \"2.21%\"], [\"Goldman Sachs\", \"2%\"], [\"American Express\", \"1.9%\"], \n",
    "       [\"HSBC\", \"2.2%\"], [\"Discover\", \"1.9%\"]]\n",
    "import numpy as np\n",
    "np_Bank_APY = np.array(Bank_APY)\n",
    "print(np_Bank_APY)\n",
    "print(type(np_Bank_APY))\n",
    "print(np_Bank_APY.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.1.3 Subsetting 2D NumPy Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Bank_APY = [[\"Citi\", \"2.21%\"], [\"Goldman Sachs\", \"2%\"], [\"American Express\", \"1.9%\"], \n",
    "       [\"HSBC\", \"2.2%\"], [\"Discover\", \"1.9%\"]]\n",
    "import numpy as np\n",
    "np_Bank_APY = np.array(Bank_APY)\n",
    "\n",
    "# Print out the 2nd row of np_Bank_APY\n",
    "print(\"The second row of np_Bank_APY is: \" + str(np_Bank_APY[1,:]))\n",
    "\n",
    "# Select the entire second column of np_Bank_APY: np_APY\n",
    "np_APY = np_Bank_APY[:,1]\n",
    "print(\"The entire second column of np_Bank_APY is \" + str(np_APY))\n",
    "\n",
    "# Print out APY of the 3rd Bank\n",
    "print(\"APY of the third Bank is: \" + np_Bank_APY[2,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3.1.4 Basic Statistics  - Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.mean\n",
    "# np.median\n",
    "# np.corrcoef\n",
    "# np.std"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Data Structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Great way to connect two lists:\n",
    "\n",
    "# Example 1:\n",
    "# Banks = [\"Citi\", \"Goldman Sachs\", \"American Express\", \"HSBC\", \"Discover\"]\n",
    "# APY = [0.0221, 0.02, 0.019, 0.022, 0.019]\n",
    "\n",
    "# Example 2:\n",
    "# countries = ['spain', 'france', 'germany', 'norway']\n",
    "# capitals = ['madrid', 'paris', 'berlin', 'oslo']\n",
    "\n",
    "# Example 3:\n",
    "# workshops = [\"Intro to Python\", \"Intro to R\", \"Random Forests on Spatial Data\", \n",
    "#              \"Intermediate Python\"]\n",
    "# registration = [22, 15, 19, 13, ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 4.1.1 Creat a dictionary from two lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "workshops = [\"Intro to Python\", \"Intro to R\", \"Random Forests on Spatial Data\",\n",
    "             \"Intermediate Python\"]\n",
    "registration = [22, 15, 19, 13]\n",
    "\n",
    "# Creat a dictionary using curly brackets {\"key1\":value1,\"key2\":value2}\n",
    "SSDA = {\"Intro to Python\": 22, \"Intro to R\": 15,\n",
    "        \"Random Forests on Spatial Data\": 19, \"Intermediate Python\": 13}\n",
    "\n",
    "# Get the number of people registered for the workshop Intermediate Python \n",
    "SSDA[\"Intermediate Python\"]\n",
    "print(\"The number of people registered for Intermediate Python is \"\n",
    "      + str(SSDA[\"Intermediate Python\"]))\n",
    "print()\n",
    "\n",
    "# In a dictionary, there are keys and values.\n",
    "# To check which keys are in a defined dictionary, use the method keys() on the dictoinary.\n",
    "print(\"What are the keys in the SSDA dictionary?\")\n",
    "print(SSDA.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.2 Creat a dictionary using zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "workshops = [\"Intro to Python\", \"Intro to R\", \"Random Forests on Spatial Data\",\n",
    "             \"Intermediate Python\"]\n",
    "registration = [22, 15, 19, 13]\n",
    "\n",
    "SSDA = dict(zip(workshops,registration))\n",
    "print(\"The number of people registered for Intermediate Python is \"\n",
    "      + str(SSDA[\"Intermediate Python\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.3 Working with a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.3.1 Add key and value to an existing dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's add today's workshop to the existing SSDA dictionary.\n",
    "# Let's call today's workshop \"Intro to Python B\"\n",
    "\n",
    "SSDA[\"Intro to Python B\"] = 34\n",
    "\n",
    "# Check if you have updated the dictionary: SSDA, successfully through:\n",
    "# (1) print (2) \"Intro to Python B\" in SSDA\n",
    "\n",
    "# Method #1\n",
    "print(\"Please check if we have successfully updated the SSDA dictionary now.\")\n",
    "print(SSDA)\n",
    "print()\n",
    "\n",
    "# Method #2\n",
    "print(\"Did we successfully update the SSDA dictionary? \" \n",
    "      + str(\"Intro to Python B\" in SSDA))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.3.2 Change the value to a key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We need to update the value of key \"Intro to Python B\" from 34 to 28.\n",
    "\n",
    "SSDA[\"Intro to Python B\"] = 28\n",
    "\n",
    "# Again, check if the value has been updated successfully\n",
    "\n",
    "print(\"Now we have \" + str(SSDA[\"Intro to Python B\"]) +\n",
    "      \" people registered in the workshop Intro to Python B.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.3.3 Delect a key from a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# While we cann't hold 28 people in this classroom and we thus have to reschedule\n",
    "# the workshop, so cancel it for now.\n",
    "del(SSDA[\"Intro to Python B\"])\n",
    "\n",
    "# Check if we have deleted the key successfully\n",
    "# Method #1\n",
    "print(\"Please check if we have Intro to Python B in the SSDA dictionary now.\")\n",
    "print(SSDA)\n",
    "print()\n",
    "\n",
    "# Method #2\n",
    "print(\"Is Intro to Ptyhon B still in the SSDA dictionary? \" +\n",
    "      str(\"Intro to Python B\" in SSDA))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.4 Dictionary of Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.4.1 Creat a dictionary with dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SSDA = { 'Intro to Python': { 'date':'3-26-2019', 'registration':22 },\n",
    "           'Intro to R': { 'date':'4-18-2019', 'registration':15 },\n",
    "           'Random Forests on Spatial Data': { 'date':'5-21-2019', 'registration':19 },\n",
    "           'Intermediate Python': { 'date':'5-29-2019', 'registration':13 } }\n",
    "print(SSDA)\n",
    "print(type(SSDA))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1.4.2 Add key and value to a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add our today's workshop information to SSDA\n",
    "SSDA[\"Intro to Python B\"] = {'date':'9-9-2019','registration':28}\n",
    "\n",
    "# Again, check if you have added it to the dictionary: SSDA, successfully.\n",
    "# Method #1\n",
    "print(\"Please check if we have Intro to Python B in the SSDA dictionary now.\")\n",
    "print(SSDA)\n",
    "print()\n",
    "\n",
    "# Method #2\n",
    "print(\"Did we successfully add Intro to Python B to the SSDA dictionary? \"\n",
    "      + str(\"Intro to Python B\" in SSDA))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open source library & high performance data manipulation tool\n",
    "# Built on Numpy:\n",
    "# Numpy has the same data type\n",
    "# Pandas have the same data type in each column,\n",
    "# but different columns can have different data types!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 4.2.1 Build a DataFrame from Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "############################################################################################################################\n",
    "#\n",
    "# DataFrame is one of Pandas' most important data structures. It's basically a way to store tabular data\n",
    "# where you can label the rows and the columns. One way to build a DataFrame is from a dictionary.\n",
    "#\n",
    "############################################################################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SSDA = { 'Intro to Python': { 'date':'3-26-2019', 'registration':22 },\n",
    "           'Intro to R': { 'date':'4-22-2019', 'registration':15 },\n",
    "           'Random Forests': { 'date':'5-21-2019', 'registration':19 },\n",
    "           'Intermediate Python': { 'date':'5-29-2019', 'registration':13 } }\n",
    "print(SSDA)\n",
    "print()\n",
    "\n",
    "import pandas as pd\n",
    "SSDA_DF = pd.DataFrame(SSDA)\n",
    "print(SSDA_DF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SSDA = {\"workshops\":[\"Intro to Python\",\"Intro to R\",\"Ramdom Forests\",\"Intermediate Python\"],\n",
    "       \"Date\":[\"3-26-2019\",\"4-22-2019\",\"5-21-2019\",\"5-29-2019\"],\n",
    "       \"Registration\":[22,15,19,13]}\n",
    "SSDA_DF = pd.DataFrame(SSDA)\n",
    "print(SSDA_DF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SSDA_DF.index = [\"I.1\",\"II.1\",\"II.2.S1\",\"I.2\"]\n",
    "print(SSDA_DF)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.2 Import DataFrame from csv files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#################################################################################\n",
    "#\n",
    "# To import CSV data into Python as a Pandas DataFrame you can use: read_csv()\n",
    "#\n",
    "#################################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "monthly_AQI = pd.read_csv(\"C:/Users/yzh/OneDrive - Michigan State University/SSDA/3. SSDA Workshops/2. Workshop Slides/Introduction to Python/AQI.csv\")\n",
    "print(monthly_AQI)\n",
    "\n",
    "# AQI=f(O3, PM2.5, PM10, CO, SO2, NO2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "monthly_AQI = pd.read_csv(\"C:/Users/yzh/OneDrive - Michigan State University/SSDA/3. SSDA Workshops/2. Workshop Slides/Introduction to Python/AQI.csv\",\n",
    "                          index_col=0)\n",
    "print(monthly_AQI)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(pd.read_csv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.3 Index and Select Data from Pandas DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Row Access []\n",
    "# my_df[start:end] e.g. my_df[0:5]\n",
    "# zero-based indexing!\n",
    "# end is exclusive!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2.3.1 Colum Selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# my_df[“col_label”] which returns Pandas Series\n",
    "# my_df[[“col_label”]] which returns Pandas DF\n",
    "# my_df[[“col_label1”,”col_label2”]] which returns a sub-DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.scatter(monthly_AQI[\"PM2.5\"],monthly_AQI[\"PM10\"])\n",
    "plt.xlabel(\"PM2.5 [ug/m3]\")\n",
    "plt.ylabel(\"PM10 [ug/m3]\")\n",
    "plt.title(\"PM2.5 vs PM10\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2.3.2 Row Selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# my_df[start:end] e.g. my_df[0:5] slicing ONLY\n",
    "# NOTE: zero-based indexing! & end is exclusive!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(monthly_AQI[1:7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2.3.3 loc and iloc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loc - label based\n",
    "# iloc - integer position based"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Row Access with loc\n",
    "# my_df.loc[“row_label”] which returns Pandas Series\n",
    "# my_df.loc[[“row_label”]] which returns Pandas DF\n",
    "# my_df.loc[[“row_label1”,”row_label2”]] which returns a sub-DataFrame\n",
    "\n",
    "# Row & Column with loc\n",
    "# my_df.loc[[“row_label1”,”row_label2”],[“col_label1”,”col_label2”]]\n",
    "# my_df.loc[:,[“col_label1”,”col_label2”]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Row Access with iloc\n",
    "# my_df.iloc[[1]] which returns Pandas DF\n",
    "# my_df.iloc[[1,2,3]] which returns a sub-DataFrame\n",
    "\n",
    "# Row & Column with iloc\n",
    "# my_df.iloc[[1,2,3],[0,1]]\n",
    "# my_df.iloc[:,[0,1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(monthly_AQI.loc[[\"2014-06\",\"2015-06\",\"2016-06\",\"2017-06\",\"2018-06\"]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.4 Explore a Pandas DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pandas Basics\n",
    "# type(pd_df)\n",
    "# pd_df.shape\n",
    "# pd_df.columns\n",
    "# pd_df.index\n",
    "# type(pd_df.index)\n",
    "# pd_df.iloc[:5,:] or pd_df.iloc[-5:,:]\n",
    "# pd_df.head(5)\n",
    "# pd_df.tail(3)\n",
    "# pd_df.info()\n",
    "# pd_df.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Explore monthly_AQI using type(), head(), tail(), info(), etc.\n",
    "\n",
    "print(\"monthly_AQI is a \"+str(type(monthly_AQI)))\n",
    "print()\n",
    "print(\"The structure of monthly_AQI is \"+str(monthly_AQI.shape))\n",
    "print()\n",
    "print(\"Columns in monthly_AQI are \"+str(monthly_AQI.columns))\n",
    "print()\n",
    "print(\"The first line in monthly_AQI is shown below:\")\n",
    "print(monthly_AQI.head(1))\n",
    "print()\n",
    "print(\"The last line in monthly_AQI is shown below:\")\n",
    "print(monthly_AQI.tail(1))\n",
    "print()\n",
    "print(\"Let's see some info of monthly_AQI\")\n",
    "print(monthly_AQI.info())\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.5 Plotting with Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "monthly_AQI = pd.read_csv(\"C:/Users/yzh/OneDrive - Michigan State University/SSDA/3. SSDA Workshops/2. Workshop Slides/Introduction to Python/AQI.csv\",\n",
    "                          index_col=0,parse_dates=True)\n",
    "\n",
    "monthly_AQI.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthly_AQI.plot(subplots=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthly_AQI[\"AQI\"].plot()\n",
    "plt.title(\"Monthly AQI\",fontsize=16)\n",
    "plt.xlabel(\"Date\",fontsize=16)\n",
    "plt.ylabel(\"AQI\",fontsize=16)\n",
    "plt.ylim(0,200)\n",
    "plt.yticks([0,50,100,150,200],[0,50,100,150,200])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot Ozone to see its seasonable variation\n",
    "# Surface O3 concentration peaks – June!\n",
    "\n",
    "monthly_AQI[\"O3\"].plot()\n",
    "plt.title(\"Monthly Surface Ozone Concentration\",fontsize=16)\n",
    "plt.xlabel(\"Date\",fontsize=16)\n",
    "plt.ylabel(\"Ozeon Concentration [ppb(v)]\")\n",
    "plt.ylim(0,200)\n",
    "plt.xticks([\"2013-6\",\"2014-6\",'2015-6','2016-6','2017-6','2018-6','2019-6'],\n",
    "           [\"2013-6\",\"2014-6\",'2015-6','2016-6','2017-6','2018-6','2019-6'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthly_AQI.plot(kind=\"scatter\",x=\"AQI\",y=\"PM10\",color='red')\n",
    "monthly_AQI.plot(kind=\"scatter\",x=\"AQI\",y=\"O3\",color='green')\n",
    "monthly_AQI.plot(kind=\"scatter\",x=\"AQI\",y=\"SO2\",color='pink')\n",
    "monthly_AQI.plot(kind=\"scatter\",x=\"AQI\",y=\"CO\",color='yellow')\n",
    "monthly_AQI.plot(kind=\"scatter\",x=\"AQI\",y=\"NO2\",color='white')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.6 Statistical exploratory data analyses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(monthly_AQI[['AQI']].describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}