Module 1P - Foundations of Data Science in Python/Week 1 Programming in Python/Week1_Programming_in_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 1 - Basics of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#1A9FFF\">Workshop outline\n",
    "<!-- \n",
    "THIS IS A R MARKDOWN CELL.\n",
    "THE CONTENT FOLLOWS R MARKDOWN STYLES.\n",
    "FOR MORE INFO, YOU MAY REFER TO https://www.rstudio.com/wp-content/uploads/2015/02/rmarkdown-cheatsheet.pdf\n",
    "-->\n",
    "\n",
    "* ** 1. Before Tutorial **\n",
    "    + Tut 1a: Suggestions\n",
    "    + Tut 1b: Installation\n",
    "    + Tut 1c: Introduction to Jupyter Notebook\n",
    "\n",
    "\n",
    "* ** 2. Python Basics ** \n",
    "    + Tut 2a: Data Type <!-- int, float, string, bool, list, dictionary (indexing slicing) -->\n",
    "    + Tut 2b: Flow Control <!-- for, if -->\n",
    "    + Tut 2c: Function\n",
    "    + Exercise 2\n",
    "    + 10 minutes break\n",
    "      \n",
    "\n",
    "* ** 3. Pandas Basics **\n",
    "    + Tut 3a: Basic Data Structure\n",
    "    + Tut 3b: Basic Statistics\n",
    "    + Exercise 3\n",
    "    + 10 minutes break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#1A9FFF\">1. Before Tutorial</span>\n",
    "## <span style=\"color:#1A9FFF\">Tut 1a. Suggestions</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul>\n",
    "    <li>** Try every code in the tutorial **</li>\n",
    "    <li>** In the class, interrupt me any time if you have any question **</li>\n",
    "    <li>** After class, search by Google first if you meet any problem **</li>\n",
    "</li> \n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## <span style=\"color:#1A9FFF\">Tut 1b. Installation</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Anaconda : ** Anaconda is a Python/R distribution. It aims to provide everything you need in Python for data science. It includes:\n",
    "    <ul>\n",
    "        <li> The core Python language </li>\n",
    "        <li> 100+ Packages (toolbox) </li>\n",
    "        <li> Jupyter Notebook and Spyder </li>\n",
    "        <li> `conda` package manager </li>\n",
    "    </ul>\n",
    "    ** Anaconda Installation Package : https://www.anaconda.com/download **\n",
    "    \n",
    "<!-- The installation may take a while, move on to the \"Introduction of Jupyter Notebook\" first. -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#1A9FFF\">Tut 1c. Introduction to Jupyter Notebook</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "** Notebook Document ** : Notebook documents are both human-readable documents containing the analysis description and the results (figures, tables, etc..) as well as executable documents which can be run to perform data analysis. \n",
    "\n",
    "** Jupyter Notebook **  : The Jupyter Notebook App is a server-client application that allows editing and running notebook documents via a web browser. The basic component of Jupyter Notebook is cell.\n",
    "    <ul>\n",
    "        <li> ` Markdown Cell ` for Rich Text ( [Tutorial](https://www.markdowntutorial.com) )</li>\n",
    "        <li> ` Code Cell ` for Excutable Code </li>\n",
    "    </ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This is a simple Markdown example\n",
    "\n",
    "*** we can make a list: ***\n",
    "+ The core Python language\n",
    "+ 100+ Packages (toolbox)\n",
    "+ Jupyter Notebook and Spyder\n",
    "+ `conda` package manager\n",
    "\n",
    "*** we can attach a link: ***\n",
    "  [link here](http://www.ntu.edu.sg/Pages/home.aspx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This is an example of excutable document (code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.117615Z",
     "start_time": "2019-08-05T07:37:41.113900Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love NTU\n",
      "I love Data Science\n",
      "I love Python!!!\n"
     ]
    }
   ],
   "source": [
    "print(\"I love NTU\")    # basic output statement in Python\n",
    "print(\"I love Data Science\")\n",
    "print(\"I love Python!!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# <span style=\"color:#1A9FFF\">2. Python Basics</span>\n",
    "## <span style=\"color:#1A9FFF\">Tut 2a. Data Type</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Data Type and Their Operations\n",
    "<ul>\n",
    "    <li> Data Type      : `Integer`, `Float`, `String`, `Bool` </li>\n",
    "    <li> Data Structure : `List`, `Dictionary` </li>\n",
    "</ul>\n",
    "\n",
    "##### Integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.134089Z",
     "start_time": "2019-08-05T07:37:41.129406Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 1 , b = 2\n"
     ]
    }
   ],
   "source": [
    "a = 1 # define a integer\n",
    "b = 2 # another integer\n",
    "\n",
    "print(\"a =\", a, \", b =\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.144493Z",
     "start_time": "2019-08-05T07:37:41.141502Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a + b = 3\n"
     ]
    }
   ],
   "source": [
    "add_c = a + b # addition of two integers\n",
    "print(\"a + b =\", add_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.154439Z",
     "start_time": "2019-08-05T07:37:41.150899Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a - b = -1\n"
     ]
    }
   ],
   "source": [
    "sub_c = a - b # substraction of two integers\n",
    "print(\"a - b =\", sub_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.165226Z",
     "start_time": "2019-08-05T07:37:41.161674Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a * b = 2\n"
     ]
    }
   ],
   "source": [
    "mul_c = a * b # multiplication of two integers\n",
    "print(\"a * b =\", mul_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.174742Z",
     "start_time": "2019-08-05T07:37:41.171091Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a / b = 0.5\n"
     ]
    }
   ],
   "source": [
    "div_c = a / b # division of two integers\n",
    "print(\"a / b =\", div_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.185906Z",
     "start_time": "2019-08-05T07:37:41.182491Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 1.0 , b = 2\n"
     ]
    }
   ],
   "source": [
    "a = 1.0  # define a float (decimal)\n",
    "b = 2    # a integer\n",
    "\n",
    "print(\"a =\", a, \", b =\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.194802Z",
     "start_time": "2019-08-05T07:37:41.191257Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a + b = 3.0\n"
     ]
    }
   ],
   "source": [
    "add_c = a + b # addition of two floats\n",
    "print(\"a + b =\", add_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.203190Z",
     "start_time": "2019-08-05T07:37:41.199431Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a - b = -1.0\n"
     ]
    }
   ],
   "source": [
    "sub_c = a - b # substraction of two floats\n",
    "print(\"a - b =\", sub_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.210550Z",
     "start_time": "2019-08-05T07:37:41.207364Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a * b = 2.0\n"
     ]
    }
   ],
   "source": [
    "mul_c = a * b # multiplication of two floats\n",
    "print(\"a * b =\", mul_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.218486Z",
     "start_time": "2019-08-05T07:37:41.215522Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a / b = 0.5\n"
     ]
    }
   ],
   "source": [
    "div_c = a / b # division of two integers\n",
    "print(\"a / b =\", div_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.225952Z",
     "start_time": "2019-08-05T07:37:41.223272Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love XXX\n"
     ]
    }
   ],
   "source": [
    "s = \"I love \"       # define a string\n",
    "something = 'XXX'   # another string\n",
    "\n",
    "print(s + something) # 'addition' of strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Bool\n",
    "`True` and `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.240451Z",
     "start_time": "2019-08-05T07:37:41.237000Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = True , b = False\n"
     ]
    }
   ],
   "source": [
    "a = True  # define a bool\n",
    "b = False # another bool\n",
    "print(\"a =\", a, \", b =\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.249941Z",
     "start_time": "2019-08-05T07:37:41.246221Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From Condition Statement\n",
      "a = False , b = True\n"
     ]
    }
   ],
   "source": [
    "# Condition Statement\n",
    "a = (2 > 3)\n",
    "b = (2 == 2)\n",
    "print(\"From Condition Statement\")\n",
    "print(\"a =\", a, \", b =\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.256715Z",
     "start_time": "2019-08-05T07:37:41.253219Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = True , b = False\n"
     ]
    }
   ],
   "source": [
    "a = True  # define a bool\n",
    "b = False # another bool\n",
    "print(\"a =\", a, \", b =\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.270935Z",
     "start_time": "2019-08-05T07:37:41.267918Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a and b = False\n"
     ]
    }
   ],
   "source": [
    "# logic operation\n",
    "and_c = a and b # \"and\" operation of two bool variables\n",
    "print(\"a and b =\", and_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.275263Z",
     "start_time": "2019-08-05T07:37:41.272621Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a or b  = True\n"
     ]
    }
   ],
   "source": [
    "or_c  = a or b  # \"or\" operation of two bool variables\n",
    "print(\"a or b  =\", or_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.279626Z",
     "start_time": "2019-08-05T07:37:41.276995Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not a   = False\n"
     ]
    }
   ],
   "source": [
    "not_c = not a   # \"not\" operation of a bool variable\n",
    "print(\"not a   =\", not_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List\n",
    "##### Create a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.294325Z",
     "start_time": "2019-08-05T07:37:41.289870Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of numbers   :  [2017, 10, 12, 15, 44, 55.0]\n",
      "List of strings   :  ['Andrew', 'Jordan', 'Hinton', 'LeCun']\n"
     ]
    }
   ],
   "source": [
    "# Define a list\n",
    "\n",
    "l_number = [2017, 10, 12, 15, 44, 55.0]             # a list of numbers\n",
    "l_string = ['Andrew', 'Jordan', 'Hinton', 'LeCun']  # a list of strings\n",
    "\n",
    "print(\"List of numbers   : \", l_number)\n",
    "print(\"List of strings   : \", l_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.302240Z",
     "start_time": "2019-08-05T07:37:41.298596Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of variables :  [3, True, 5.0, 'True']\n"
     ]
    }
   ],
   "source": [
    "a = 3       # a integer\n",
    "b = True    # a bool\n",
    "c = 5.0     # a float\n",
    "d = 'True'  # a string\n",
    "\n",
    "l_variable = [a, b, c, d] # a combination of different data types\n",
    "\n",
    "print(\"List of variables : \", l_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Indexing of list\n",
    "* use a integer with a bracket `[]`\n",
    "* index starts from `0`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.310015Z",
     "start_time": "2019-08-05T07:37:41.307294Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Andrew', 'Jordan', 'Hinton', 'LeCun']\n"
     ]
    }
   ],
   "source": [
    "# 1. Indexing of list\n",
    "\n",
    "l_string = ['Andrew', 'Jordan', 'Hinton', 'LeCun']  # a list of strings\n",
    "#               0         1         2        3      positive indexing\n",
    "#              -4        -3        -2       -1      negative indexing\n",
    "print(l_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.320513Z",
     "start_time": "2019-08-05T07:37:41.316156Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. Indexing of list >\n",
      "Positive Indexing : Andrew\n",
      "Negative Indexing : LeCun\n",
      "Slicing  : ['Andrew', 'Jordan']\n"
     ]
    }
   ],
   "source": [
    "print(\"< 1. Indexing of list >\")\n",
    "print(\"Positive Indexing :\", l_string[0])   # indexing, select the first string (positive index)\n",
    "print(\"Negative Indexing :\", l_string[-1])  # indexing, select the last string (negative index)\n",
    "print(\"Slicing  :\", l_string[0:2])          # slicing,  select the first and second string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.328476Z",
     "start_time": "2019-08-05T07:37:41.324894Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. Change one of the elements >\n",
      "Original List    : ['Andrew', 'Jordan', 'Hinton', 'LeCun']\n",
      "Replace 'Jordan' : ['Andrew', 'Yoshua', 'Hinton', 'LeCun']\n"
     ]
    }
   ],
   "source": [
    "# 2. Change one of the elements\n",
    "\n",
    "print(\"< 2. Change one of the elements >\")\n",
    "print(\"Original List    :\", l_string)\n",
    "l_string[1] = 'Yoshua'\n",
    "print(\"Replace 'Jordan' :\", l_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.338634Z",
     "start_time": "2019-08-05T07:37:41.333697Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 3. String is a list of char >\n",
      "Original string        : Andrew\n",
      "First character        : A\n",
      "2nd - 5th characters   : ndre\n",
      "2nd - End characters   : drew\n",
      "First - 3rd characters : And\n"
     ]
    }
   ],
   "source": [
    "# 3. String is a list of char (character)\n",
    "\n",
    "print (\"< 3. String is a list of char >\")\n",
    "s = 'Andrew'\n",
    "# 'A' 'n' 'd' 'r' 'e' 'w' \n",
    "#  0   1   2   3   4   5\n",
    "print (\"Original string        :\", s)\n",
    "print (\"First character        :\", s[0])    # select the first character\n",
    "print (\"2nd - 5th characters   :\", s[1:5])  # select the second to the Fifth character\n",
    "print (\"2nd - End characters   :\", s[2:])   # select the third character and the following characters in the string\n",
    "print (\"First - 3rd characters :\", s[:3])   # select the first, second and third characters in the string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary\n",
    "give each item a name ( indexing with a pre-defined 'name'， ***key*** )\n",
    "\n",
    "** { <span style=\"color:#FF8B33\">'key1'</span> : value1 , <span style=\"color:#FF8B33\">'key2'</span> : value2 , . . . , <span style=\"color:#FF8B33\">'keyN'</span> : valueN } **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.347774Z",
     "start_time": "2019-08-05T07:37:41.344387Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. Define a dictionary >\n",
      "dictionary d : {'int': 1, 'float': 1.0, 'bool': True, '1': 'Andrew', '2': 'Hinton', '3': 'LeCun'}\n"
     ]
    }
   ],
   "source": [
    "# 1. Define a dictionary\n",
    "# define with a curly brace{}\n",
    "\n",
    "d = {'int':1, 'float':1.0, 'bool':True, '1': 'Andrew', '2':'Hinton', '3':'LeCun'}\n",
    "print (\"< 1. Define a dictionary >\")\n",
    "print (\"dictionary d :\", d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.361533Z",
     "start_time": "2019-08-05T07:37:41.352990Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'year': 2017}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2. Define an empty dictionary\n",
    "d_e = {}\n",
    "d_e['year']  = 2017\n",
    "d_e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.366773Z",
     "start_time": "2019-08-05T07:37:41.363243Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. Define an empty dictionary >\n",
      "from an empty dictionary : {'year': 2017, 'month': 'October', 'day': 12}\n"
     ]
    }
   ],
   "source": [
    "d_e['month'] = 'October'\n",
    "d_e['day']   = 12\n",
    "print(\"< 2. Define an empty dictionary >\")\n",
    "print(\"from an empty dictionary :\", d_e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.373132Z",
     "start_time": "2019-08-05T07:37:41.368523Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 3. Indexing of dictionary >\n",
      "item 'int'     : 1\n",
      "item 'bool'    : True\n",
      "item '1''2''3' : Andrew Hinton LeCun\n"
     ]
    }
   ],
   "source": [
    "# 3. Indexing of dictionary\n",
    "# use a key with bracket []\n",
    "print (\"< 3. Indexing of dictionary >\")\n",
    "print (\"item 'int'     :\", d['int'])\n",
    "print (\"item 'bool'    :\", d['bool'])\n",
    "print (\"item '1''2''3' :\", d['1'], d['2'], d['3'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.386857Z",
     "start_time": "2019-08-05T07:37:41.383141Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 4. Replace value of an item >\n",
      "original dictionary : {'int': 1, 'float': 1.0, 'bool': True, '1': 'Andrew', '2': 'Hinton', '3': 'LeCun'}\n",
      "modified dictionary : {'int': 10, 'float': 1.0, 'bool': True, '1': 'Andrew', '2': 'Hinton', '3': 'LeCun'}\n"
     ]
    }
   ],
   "source": [
    "# 4. Replace value of an item\n",
    "print (\"< 4. Replace value of an item >\")\n",
    "print (\"original dictionary :\", d)\n",
    "d['int']  = 10\n",
    "print (\"modified dictionary :\", d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List v.s. Dictionary\n",
    "<ul>\n",
    "    <li> Indexing in Dictionary is faster than List </li>\n",
    "    <li> Dictionary costs much more mermory than List </li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#1A9FFF\">Tut 2b. Flow Control</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If Statement\n",
    "Run code based conditions\n",
    "<img src=\"res/if.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### A Simple Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.395653Z",
     "start_time": "2019-08-05T07:37:41.391947Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The condition is True\n"
     ]
    }
   ],
   "source": [
    "condition = True  # define a bool variable called \"condition\"\n",
    "\n",
    "if condition:\n",
    "    print (\"The condition is True\")\n",
    "else:\n",
    "    print (\"The condition is False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Using Condition Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.408374Z",
     "start_time": "2019-08-05T07:37:41.404731Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "give him an apple\n"
     ]
    }
   ],
   "source": [
    "# define a float variable recording a student's height\n",
    "# if the student is higher than 160.0cm, he will be given an apple\n",
    "# if the student is lower than 160.0cm,  he will be given a banana\n",
    "\n",
    "height = 170.0  # the height of the student\n",
    "\n",
    "if height > 160.0:\n",
    "    print (\"give him an apple\")\n",
    "else:\n",
    "    print (\"give him a banana\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### if, elif, else\n",
    "\n",
    " <ul>\n",
    "    <li> `if, else` is just binary-branch flow control statement. </li>\n",
    "    <li> For multi-branch flow control, we can use `if, elif, else`. </li>\n",
    "</ul>\n",
    "\n",
    "\n",
    "More complicated case:\n",
    "<img src=\"res/gpa.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.421629Z",
     "start_time": "2019-08-05T07:37:41.417421Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grade : C\n"
     ]
    }
   ],
   "source": [
    "# decide the grade of a student based on the score provided\n",
    "\n",
    "score = 75 # score of a student\n",
    "\n",
    "if   score >= 90:\n",
    "    print (\"Grade : A\")\n",
    "    \n",
    "elif score >= 80:\n",
    "    print (\"Grade : B\")\n",
    "    \n",
    "elif score >= 70:\n",
    "    print (\"Grade : C\")\n",
    "    \n",
    "elif score >= 60:\n",
    "    print (\"Grade : D\")\n",
    "\n",
    "else:\n",
    "    print (\"Grade : F (so sad ...)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For Loop\n",
    "Repeat codes many times, with a variable changing as the way we define\n",
    "<img src=\"res/for.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### A simple example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.433938Z",
     "start_time": "2019-08-05T07:37:41.429699Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. A simple example >\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# print the iter_variable repeatedly with the value of iter_variable changed from 0 to 3\n",
    "\n",
    "# 1. A simple example\n",
    "\n",
    "print (\"< 1. A simple example >\")\n",
    "for iter_variable in [0, 1, 2, 3]:\n",
    "    print (iter_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.439899Z",
     "start_time": "2019-08-05T07:37:41.435892Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. A more convinient way >\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# 2. A more convinient way\n",
    "\n",
    "print (\"< 2. A more convinient way >\")\n",
    "for iter_variable in range(4):   # we can change the number in range() to any positive integer\n",
    "    print (iter_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.450128Z",
     "start_time": "2019-08-05T07:37:41.446057Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 3. A flexible way >\n",
      "4\n",
      "3\n",
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "# 3. A flexible way\n",
    "\n",
    "print (\"< 3. A flexible way >\")\n",
    "\n",
    "rangeList = [4, 3, 5, 7]\n",
    "\n",
    "for iter_variable in rangeList:\n",
    "    print (iter_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Repeat an operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.458947Z",
     "start_time": "2019-08-05T07:37:41.454797Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. The most naive way >\n",
      "sum from 1 to 10 : 55\n"
     ]
    }
   ],
   "source": [
    "# sum up the numbers from 1 to 10\n",
    "\n",
    "# 1. The most naive way\n",
    "\n",
    "print (\"< 1. The most naive way >\")\n",
    "sum_10 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10\n",
    "print (\"sum from 1 to 10 :\", sum_10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.469569Z",
     "start_time": "2019-08-05T07:37:41.465498Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. The right way to do >\n",
      "sum from 1 to 10 : 55\n"
     ]
    }
   ],
   "source": [
    "# 2. The right way to do\n",
    "\n",
    "print (\"< 2. The right way to do >\")\n",
    "sum_10 = 0                    # define a variable to accumulate the numbers\n",
    "for i in range(10):\n",
    "    sum_10 = sum_10 + (i + 1)\n",
    "print (\"sum from 1 to 10 :\", sum_10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.478471Z",
     "start_time": "2019-08-05T07:37:41.474261Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 3. More numbers involved >\n",
      "sum from 1 to 1000 : 500500\n"
     ]
    }
   ],
   "source": [
    "# 3. More numbers involved\n",
    "\n",
    "print (\"< 3. More numbers involved >\")\n",
    "sum_1000 = 0                    # define a variable to accumulate the numbers\n",
    "for i in range(1000):\n",
    "    sum_1000 = sum_1000 + (i + 1)\n",
    "print (\"sum from 1 to 1000 :\", sum_1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loop\n",
    "Repeat codes until condition is not satisfied\n",
    "<img src=\"res/while.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### A simple example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.489715Z",
     "start_time": "2019-08-05T07:37:41.486166Z"
    }
   },
   "outputs": [],
   "source": [
    "# A DANGEROUS case\n",
    "condition = True\n",
    "\n",
    "while condition:\n",
    "    print (\"I'm in.\")\n",
    "#     condition = False\n",
    "    \n",
    "print (\"I'm out\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Repeat an operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.501305Z",
     "start_time": "2019-08-05T07:37:41.497169Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum from 1 to 100 : 5050\n"
     ]
    }
   ],
   "source": [
    "# sum up the numbers from 1 to 100\n",
    "\n",
    "counter = 1\n",
    "sum_100 = 0\n",
    "\n",
    "while counter <= 100:\n",
    "    sum_100 = sum_100 + counter\n",
    "    counter = counter + 1\n",
    "    \n",
    "print (\"sum from 1 to 100 :\", sum_100)\n",
    "    \n",
    "# illustration code\n",
    "# counter = 1\n",
    "# sum_9   = 0\n",
    "# print \"counter\", \" sum_9\", '\\n'\n",
    "# while counter <= 9:\n",
    "#     sum_9 = sum_9 + counter\n",
    "#     print counter, \"         \", sum_9\n",
    "#     counter = counter + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#1A9FFF\">Tut 2c. Function</span>\n",
    "\n",
    "### Definition of Function\n",
    "Enclosing codes so that it can be called repeatedly and flexibly\n",
    "<img src=\"res/function.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.512593Z",
     "start_time": "2019-08-05T07:37:41.507857Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. A simple example >\n",
      "Output of sumUp function : 55\n"
     ]
    }
   ],
   "source": [
    "# 1. A simple example\n",
    "\n",
    "# define a function sum up numbers from 1 to n (n is the input parameter)\n",
    "def sumUp(n):          # user-defined function\n",
    "    \n",
    "    # initialize a variable\n",
    "    sum_n = 0\n",
    "    \n",
    "    # use \"for loop\" to implement sum up function, based on input parameter \"n\"\n",
    "    for i in range(n):\n",
    "        sum_n = sum_n + (i+1)\n",
    "    \n",
    "    # output the result, end of the function\n",
    "    return sum_n\n",
    "\n",
    "# ================================================\n",
    "n = 10\n",
    "print (\"< 1. A simple example >\")\n",
    "print (\"Output of sumUp function :\", sumUp(n))\n",
    "# ================================================"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.519357Z",
     "start_time": "2019-08-05T07:37:41.514409Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. Multiple outputs >\n",
      "a + b = 3 + 5 = 8\n"
     ]
    }
   ],
   "source": [
    "# 2. Multiple iuputs\n",
    "\n",
    "# define a function sum up two input variables \"a\" and \"b\"\n",
    "def addUp(a, b):\n",
    "    \n",
    "    return a+b\n",
    "\n",
    "# ================================================\n",
    "a = 3\n",
    "b = 5\n",
    "print (\"< 2. Multiple outputs >\")\n",
    "print (\"a + b =\", a, \"+\", b, \"=\", addUp(a,b))\n",
    "# ================================================"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.531186Z",
     "start_time": "2019-08-05T07:37:41.525378Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 3. Multiple outputs >\n",
      "Output of sumMulUp function : 55 3628800\n"
     ]
    }
   ],
   "source": [
    "# 3. Multiple outputs\n",
    "\n",
    "# define a function sum up and multiple up numbers from 1 to n (n is the input parameter)\n",
    "def sumMulUp(n):\n",
    "    \n",
    "    # initialize two variables\n",
    "    sum_n = 0   # for summation\n",
    "    mul_n = 1   # for multiplication\n",
    "    \n",
    "    for i in range(n):\n",
    "        sum_n = sum_n + (i+1)\n",
    "        mul_n = mul_n * (i+1)\n",
    "    \n",
    "    # output two results, end of the function\n",
    "    return sum_n, mul_n\n",
    "\n",
    "# ================================================\n",
    "n = 10\n",
    "print (\"< 3. Multiple outputs >\")\n",
    "sum_n, mul_n = sumMulUp(n)\n",
    "print (\"Output of sumMulUp function :\", sum_n, mul_n)\n",
    "# ================================================"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built-in functions in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### for List and Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.544159Z",
     "start_time": "2019-08-05T07:37:41.540121Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. Generate a list >\n",
      "The generated list : \n",
      " [2, 7, 9, 5, 3, 1, 4, 6, 8, 0]\n"
     ]
    }
   ],
   "source": [
    "# ============== List ==================== \n",
    "\n",
    "# 1. Generate a list with numbers from 0 to 9 with random order\n",
    "\n",
    "import random # import a package that helps generate random number \n",
    "l = random.sample(range(10), 10)\n",
    "print (\"< 1. Generate a list >\")\n",
    "print (\"The generated list :\", '\\n', l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.549336Z",
     "start_time": "2019-08-05T07:37:41.545934Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. Check the length of a list >\n",
      "The length of generated list : 10\n"
     ]
    }
   ],
   "source": [
    "# 2. Check the length of the generated list\n",
    "\n",
    "len_l = len(l)                # \"global\" function\n",
    "print (\"< 2. Check the length of a list >\")\n",
    "print (\"The length of generated list :\", len_l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.558707Z",
     "start_time": "2019-08-05T07:37:41.554744Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 3. Find max and min >\n",
      "The max number of generated list : 9\n",
      "The min number of generated list : 0\n"
     ]
    }
   ],
   "source": [
    "# 3. Find the maximum and minimum number of the generated list\n",
    "\n",
    "max_l = max(l)                # \"global\" function\n",
    "min_l = min(l)\n",
    "print (\"< 3. Find max and min >\")\n",
    "print (\"The max number of generated list :\", max_l)\n",
    "print (\"The min number of generated list :\", min_l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.566512Z",
     "start_time": "2019-08-05T07:37:41.563259Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 4. Sort a list >\n",
      "The sorted list : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# 4. Sort the generated list in accending order\n",
    "\n",
    "l.sort()                      # member function\n",
    "                              # no return for this function\n",
    "print (\"< 4. Sort a list >\")\n",
    "print (\"The sorted list :\", l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.575995Z",
     "start_time": "2019-08-05T07:37:41.572737Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 5. Reverse a list >\n",
      "The reversed list : [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# 5. Reverse the generated list\n",
    "\n",
    "l.reverse()                   # member function\n",
    "                              # no return for this function\n",
    "print (\"< 5. Reverse a list >\")\n",
    "print (\"The reversed list :\", l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.583861Z",
     "start_time": "2019-08-05T07:37:41.580698Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 6. Add a new item in list >\n",
      "The new list : [9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 100]\n"
     ]
    }
   ],
   "source": [
    "# 6. Add a new item at the end of the list\n",
    "\n",
    "l.append(100)                 # member function\n",
    "                              # no return for this function\n",
    "print (\"< 6. Add a new item in list >\")\n",
    "print (\"The new list :\", l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.592221Z",
     "start_time": "2019-08-05T07:37:41.589234Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 7. Get index of a certain item in list >\n",
      "The index of 100 : 10\n"
     ]
    }
   ],
   "source": [
    "# 7. Get index of a certain item in list\n",
    "\n",
    "idx_100 = l.index(100)        # member function\n",
    "print (\"< 7. Get index of a certain item in list >\")\n",
    "print (\"The index of 100 :\", idx_100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.601846Z",
     "start_time": "2019-08-05T07:37:41.598764Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 8. Delete a item in list >\n",
      "The new list : [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# 8. Delete a item in list\n",
    "\n",
    "del l[idx_100]                # member function\n",
    "print (\"< 8. Delete a item in list >\")\n",
    "print (\"The new list :\", l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.610713Z",
     "start_time": "2019-08-05T07:37:41.607156Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. Define a dictionary >\n",
      "The defined dictionary : {'name': 'Nanyang Technological University', 'location': 'Singapore', 'birth': 1991}\n"
     ]
    }
   ],
   "source": [
    "# ============== Dictionary ==================== \n",
    "\n",
    "# 1. Define a dictionary\n",
    "d = {'name':'Nanyang Technological University', 'location':'Singapore', 'birth':1990, 'birth':1991} # repeated name\n",
    "                                                                                      # the last one will be recorded\n",
    "print (\"< 1. Define a dictionary >\")\n",
    "print (\"The defined dictionary :\", d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.618108Z",
     "start_time": "2019-08-05T07:37:41.615100Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. Check the length of a dictionary >\n",
      "The length of generated dictionary : 3\n"
     ]
    }
   ],
   "source": [
    "# 2. Check the length of the generated dictionary\n",
    "\n",
    "len_d = len(d)                # \"global\" function\n",
    "print (\"< 2. Check the length of a dictionary >\")\n",
    "print (\"The length of generated dictionary :\", len_d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.627124Z",
     "start_time": "2019-08-05T07:37:41.623587Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 3. Check the key of all items in dictionary >\n",
      "The keys defined in the generated dictionary : dict_keys(['name', 'location', 'birth'])\n"
     ]
    }
   ],
   "source": [
    "# 3. Check the key of all items in a dictionary\n",
    "\n",
    "keys_d = d.keys()             # member function\n",
    "print (\"< 3. Check the key of all items in dictionary >\")\n",
    "print (\"The keys defined in the generated dictionary :\", keys_d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.637484Z",
     "start_time": "2019-08-05T07:37:41.633313Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 4. Check the value of all items in dictionary >\n",
      "The value of all items in the generated dictionary : dict_values(['Nanyang Technological University', 'Singapore', 1991])\n"
     ]
    }
   ],
   "source": [
    "# 4. Check the value of all items in a dictionary\n",
    "\n",
    "values_d = d.values()         # member function\n",
    "print (\"< 4. Check the value of all items in dictionary >\")\n",
    "print (\"The value of all items in the generated dictionary :\", values_d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.646877Z",
     "start_time": "2019-08-05T07:37:41.642298Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 5. Delete one item in a dictionary >\n",
      "The motified dictionary : {'name': 'Nanyang Technological University', 'birth': 1991}\n"
     ]
    }
   ],
   "source": [
    "# 5. Delete one item in a dictionary\n",
    "\n",
    "del d['location']             # member function\n",
    "                              # no return for this function\n",
    "print (\"< 5. Delete one item in a dictionary >\")\n",
    "print (\"The motified dictionary :\", d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.655408Z",
     "start_time": "2019-08-05T07:37:41.651333Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 6. Clear all items in a dictionary >\n",
      "The cleared dictionary : {}\n"
     ]
    }
   ],
   "source": [
    "# 6. Clear all items in a dictionary\n",
    "\n",
    "d.clear()                     # member function\n",
    "                              # no return for this function\n",
    "print (\"< 6. Clear all items in a dictionary >\")\n",
    "print (\"The cleared dictionary :\", d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#FF8B33\">Exercise 2 (10 mins break)</span> \n",
    "Open `Week1 - Exercise 2.ipynb` and complete the exercises."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#1A9FFF\">3. Pandas Basics </span>\n",
    "\n",
    "Pandas is a newer package built on top of NumPy, and provides an efficient implementation of a `DataFrame`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:41.997477Z",
     "start_time": "2019-08-05T07:37:41.661451Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy  as np    # import packages\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## <span style=\"color:#1A9FFF\">Tut 3a. Basic Data Structure </span>\n",
    "<ul>\n",
    "    <li>`Series` : One-dimensional data structure with any data type</li>\n",
    "    <li>`DataFrame` : Two-dimensional data structure with different data type</li>\n",
    "    <li>`Panel`  : Three-dimensional data structure</li>\n",
    "    <li>`PanelND`: N-dimensional data structure </li>\n",
    "</ul>\n",
    "More details : [Pandas - Basic Data Structure](https://pandas.pydata.org/pandas-docs/stable/dsintro.html#dsintro)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Series\n",
    "A Pandas Series is a one-dimensional array of indexed data. Compared with `list` in Python and `ndarray` in Numpy, the index of Pandas Series is explicitly defined.\n",
    "\n",
    "One indexing, ** \"`index`\" **"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Definition\n",
    "** `pd.Series(data, index=index)` ** index is default parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.004929Z",
     "start_time": "2019-08-05T07:37:41.999428Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. Create series with a list >\n",
      "A Series defined from a list:\n",
      " 0    1.0\n",
      "1    3.0\n",
      "2    5.0\n",
      "3    NaN\n",
      "4    6.0\n",
      "5    8.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 1. Create a Series with a list\n",
    "s = pd.Series([1,3,5,np.nan,6,8])                                        # default index starts from 0\n",
    "print (\"< 1. Create series with a list >\")                                 # 'nan' is a specific symbol for missing data\n",
    "print (\"A Series defined from a list:\\n\", s)                               # 'nan' = not a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.012580Z",
     "start_time": "2019-08-05T07:37:42.007173Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. Create series with a dictionary >\n",
      "A Series defined from a dictionary:\n",
      " Ohio      35000\n",
      "Texas     71000\n",
      "Oregon    16000\n",
      "Utah       5000\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 2. Create a Series with a dictionary\n",
    "d = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}       # user-defined index\n",
    "s = pd.Series(d)\n",
    "print (\"< 2. Create series with a dictionary >\")\n",
    "print (\"A Series defined from a dictionary:\\n\", s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.020125Z",
     "start_time": "2019-08-05T07:37:42.014810Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 3. Create a Series with nonsequential indices >\n",
      "A Series defined with nonsequential indices:\n",
      " 2    0.25\n",
      "5    0.50\n",
      "3    0.75\n",
      "7    1.00\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 3. Create a Series with nonsequential indices\n",
    "s = pd.Series([0.25, 0.5, 0.75, 1.0], index=[2, 5, 3, 7])\n",
    "print (\"< 3. Create a Series with nonsequential indices >\")\n",
    "print (\"A Series defined with nonsequential indices:\\n\", s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.027137Z",
     "start_time": "2019-08-05T07:37:42.021815Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 4. Create series with an array of char >\n",
      "A Series defined from an array of char:\n",
      " n    0.053815\n",
      "t    1.197676\n",
      "u   -0.249929\n",
      "e   -1.383520\n",
      "e    1.629362\n",
      "e    1.108482\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 4. Create a Series with an array of char\n",
    "s = pd.Series(np.random.randn(6), index=['n', 't', 'u', 'e', 'e', 'e'])  # repeated indices\n",
    "print (\"< 4. Create series with an array of char >\")\n",
    "print (\"A Series defined from an array of char:\\n\", s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.034198Z",
     "start_time": "2019-08-05T07:37:42.028836Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 5. Attributes values and index >\n",
      "Values in Series s : [ 1.  3.  5. nan  6.  8.]\n",
      "Indices in Series s: RangeIndex(start=0, stop=6, step=1)\n"
     ]
    }
   ],
   "source": [
    "# 5. Attributes values and index\n",
    "s = pd.Series([1,3,5,np.nan,6,8])\n",
    "val_s = s.values\n",
    "idx_s = s.index\n",
    "print (\"< 5. Attributes values and index >\")\n",
    "print (\"Values in Series s :\", val_s)\n",
    "print (\"Indices in Series s:\", idx_s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.040289Z",
     "start_time": "2019-08-05T07:37:42.035901Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 6. Naming >\n",
      "After naming :\n",
      " num\n",
      "0    1.0\n",
      "1    3.0\n",
      "2    5.0\n",
      "3    NaN\n",
      "4    6.0\n",
      "5    8.0\n",
      "Name: example, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 6. Give a Series and its index names\n",
    "s.name        = 'example'\n",
    "s.index.name  = 'num'\n",
    "print (\"< 6. Naming >\")\n",
    "print (\"After naming :\\n\", s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Indexing\n",
    "Similar to list in Python, we can access data in Series by using square-bracket notation `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.048214Z",
     "start_time": "2019-08-05T07:37:42.043281Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. Indexing with numbers >\n",
      "0    1.0\n",
      "1    3.0\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 1. Indexing with numbers\n",
    "s = pd.Series([1,3,5,np.nan,6,8]) \n",
    "print (\"< 1. Indexing with numbers >\")\n",
    "print (s[0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.056846Z",
     "start_time": "2019-08-05T07:37:42.050303Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. Indexing with user-defined indices >\n",
      "\n",
      "original series :        <==== [ index is drawn from the sorted keys ]\n",
      "Ohio      35000\n",
      "Texas     71000\n",
      "Oregon    16000\n",
      "Utah       5000\n",
      "dtype: int64 \n",
      "\n",
      "series slicing :\n",
      "Ohio     35000\n",
      "Texas    71000\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 2. Indexing with user-defined indices\n",
    "d = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}       # user-defined index\n",
    "s = pd.Series(d)\n",
    "print (\"< 2. Indexing with user-defined indices >\\n\")\n",
    "print (\"original series :        <==== [ index is drawn from the sorted keys ]\")\n",
    "print (s, '\\n')   \n",
    "print (\"series slicing :\")\n",
    "print (s['Ohio':'Texas'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DataFrame\n",
    "`DataFrame`s are essentially multidimensional arrays with attached **`row`** and **`column`** labels, and often with heterogeneous types and/or missing data.\n",
    "\n",
    "Two indexings, ** \"`index`\" ** for row indexing and ** \"`columns`\" ** for column indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.068400Z",
     "start_time": "2019-08-05T07:37:42.058569Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. Create from a dictionary of Series >\n",
      "         Age  Height\n",
      "Andrew  30.0     154\n",
      "Emma    21.0     177\n",
      "John    27.0     165\n",
      "Steven   NaN     169     <====[ Steven's age is not provided ]\n"
     ]
    }
   ],
   "source": [
    "# 1. Create from a dictionary of Series (with missing data filled in)\n",
    "\n",
    "d = {'Age'    : pd.Series([27, 21, 30],         index=['John', 'Emma', 'Andrew']), \n",
    "     'Height' : pd.Series([165, 177, 154, 169], index=['John', 'Emma', 'Andrew', 'Steven'])}\n",
    "df_ds = pd.DataFrame(d)\n",
    "\n",
    "print (\"< 1. Create from a dictionary of Series >\")\n",
    "print (df_ds, \"    <====[ Steven's age is not provided ]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.077335Z",
     "start_time": "2019-08-05T07:37:42.070123Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. Create from a list of dictionaries  >\n",
      "   list1  list2\n",
      "0      1      2\n",
      "1      2      4\n",
      "2      3      6\n",
      "3      4      8\n",
      "4      5     10\n"
     ]
    }
   ],
   "source": [
    "# 2. Create from a list of dictionaries \n",
    "l_1 = [1, 2, 3, 4, 5]\n",
    "l_2 = [2, 4, 6, 8, 10]\n",
    "l_d = {'list1': l_1, 'list2':l_2}   # 2*l, each item in list l is multiplied by 2\n",
    "df_ld = pd.DataFrame(l_d)\n",
    "\n",
    "print (\"< 2. Create from a list of dictionaries  >\")\n",
    "print (df_ld)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Simple Indexing\n",
    "\n",
    "select rows ( items ) and columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.084565Z",
     "start_time": "2019-08-05T07:37:42.079098Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. Indexing with names >\n",
      "         Age  Height\n",
      "Andrew  30.0     154\n",
      "Emma    21.0     177\n"
     ]
    }
   ],
   "source": [
    "# 1. Indexing with pre-defined name (rows)\n",
    "print (\"< 1. Indexing with names >\")\n",
    "print (df_ds['Andrew':'Emma'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.093395Z",
     "start_time": "2019-08-05T07:37:42.086275Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. Indexing with numbers >\n",
      "   list1  list2\n",
      "3      4      8\n",
      "4      5     10\n"
     ]
    }
   ],
   "source": [
    "# 2. Indexing with numbers (rows)\n",
    "l_1 = [1, 2, 3, 4, 5]\n",
    "l_2 = [2, 4, 6, 8, 10]\n",
    "l_d = {'list1': l_1, 'list2':l_2}  \n",
    "df_ld = pd.DataFrame(l_d)\n",
    "\n",
    "print (\"< 2. Indexing with numbers >\")\n",
    "print (df_ld[3:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.100468Z",
     "start_time": "2019-08-05T07:37:42.095106Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 3. Select a column by names >\n",
      "Andrew    30.0\n",
      "Emma      21.0\n",
      "John      27.0\n",
      "Steven     NaN\n",
      "Name: Age, dtype: float64 \n",
      "\n",
      "0     2\n",
      "1     4\n",
      "2     6\n",
      "3     8\n",
      "4    10\n",
      "Name: list2, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# 3. Select columns\n",
    "print (\"< 3. Select a column by names >\")\n",
    "print (df_ds[:]['Age'], '\\n')\n",
    "print (df_ld[:]['list2'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index Object\n",
    "Both the Series and DataFrame objects contain an explicit **`index`** that helps you reference and modify data. It is an `immutable array` and `ordered set`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.107433Z",
     "start_time": "2019-08-05T07:37:42.102163Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The created Index objects\n",
      " Int64Index([1, 3, 5, 7, 9, 11], dtype='int64') \n",
      " Int64Index([2, 4, 5, 7, 9, 12], dtype='int64')\n"
     ]
    }
   ],
   "source": [
    "# Create a Index object\n",
    "idx1 = pd.Index([1, 3, 5, 7, 9, 11])\n",
    "idx2 = pd.Index([2, 4, 5, 7, 9, 12])\n",
    "\n",
    "print(\"The created Index objects\\n\", idx1, '\\n', idx2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.112978Z",
     "start_time": "2019-08-05T07:37:42.109155Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Int64Index([3, 5, 7, 9, 11], dtype='int64')\n",
      "Int64Index([2, 4, 5, 7], dtype='int64')\n"
     ]
    }
   ],
   "source": [
    "# Indexing with integers\n",
    "print (idx1[1:])\n",
    "print (idx2[:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.119190Z",
     "start_time": "2019-08-05T07:37:42.114762Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size of the index      : 6\n",
      "shape of the index     : (6,)\n",
      "dimension of the index : 1\n",
      "type of the index      : int64\n"
     ]
    }
   ],
   "source": [
    "# Attributes - size, shape, ndim, dtype\n",
    "print (\"size of the index      :\", idx1.size)\n",
    "print (\"shape of the index     :\", idx1.shape)\n",
    "print (\"dimension of the index :\", idx1.ndim)\n",
    "print (\"type of the index      :\", idx1.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Property"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.126450Z",
     "start_time": "2019-08-05T07:37:42.120881Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection of idx1 and idx2         : Int64Index([5, 7, 9], dtype='int64')\n",
      "Union of idx1 and idx2                : Int64Index([1, 2, 3, 4, 5, 7, 9, 11, 12], dtype='int64')\n",
      "Symmetric difference of idx1 and idx2 : Int64Index([1, 2, 3, 4, 11, 12], dtype='int64')\n"
     ]
    }
   ],
   "source": [
    "# Immutable (values in Index cannot be changed)\n",
    "# idx1[0] = 0\n",
    "\n",
    "\n",
    "# Set operation\n",
    "print (\"Intersection of idx1 and idx2         :\", idx1 & idx2)\n",
    "print (\"Union of idx1 and idx2                :\", idx1 | idx2)\n",
    "print (\"Symmetric difference of idx1 and idx2 :\", idx1 ^ idx2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## <span style=\"color:#1A9FFF\">Tut 3b. Basic Statistics </span>\n",
    "Basic statistics on DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.144275Z",
     "start_time": "2019-08-05T07:37:42.128071Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>area_water</th>\n",
       "      <th>population</th>\n",
       "      <th>area_total</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>AZ</th>\n",
       "      <td>1.0</td>\n",
       "      <td>6.90</td>\n",
       "      <td>295.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CA</th>\n",
       "      <td>20.5</td>\n",
       "      <td>39.30</td>\n",
       "      <td>424.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>FL</th>\n",
       "      <td>31.4</td>\n",
       "      <td>20.60</td>\n",
       "      <td>170.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>HI</th>\n",
       "      <td>11.7</td>\n",
       "      <td>1.43</td>\n",
       "      <td>28.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MI</th>\n",
       "      <td>104.1</td>\n",
       "      <td>9.93</td>\n",
       "      <td>250.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PA</th>\n",
       "      <td>3.4</td>\n",
       "      <td>12.80</td>\n",
       "      <td>119.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TX</th>\n",
       "      <td>19.1</td>\n",
       "      <td>27.90</td>\n",
       "      <td>695.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>VA</th>\n",
       "      <td>8.5</td>\n",
       "      <td>8.40</td>\n",
       "      <td>110.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>WA</th>\n",
       "      <td>12.5</td>\n",
       "      <td>7.30</td>\n",
       "      <td>184.7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    area_water  population  area_total\n",
       "AZ         1.0        6.90       295.2\n",
       "CA        20.5       39.30       424.0\n",
       "FL        31.4       20.60       170.3\n",
       "HI        11.7        1.43        28.3\n",
       "MI       104.1        9.93       250.5\n",
       "PA         3.4       12.80       119.3\n",
       "TX        19.1       27.90       695.7\n",
       "VA         8.5        8.40       110.8\n",
       "WA        12.5        7.30       184.7"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a DataFrame\n",
    "# AZ = Arizona, CA = California, FL = Florida\n",
    "# HI = Hawaii,  MI = Michigan,   PA = Pennsylvania\n",
    "# TX = Texas,   VA = Virginia,   WA = Washington\n",
    "\n",
    "s_popu  = pd.Series([6.9,   39.3,  20.6,  1.43, 9.93,  12.8,  27.9,  8.4,   7.3],   index=['AZ', 'CA', 'FL', 'HI', 'MI', 'PA', 'TX', 'VA', 'WA'])  # million persons\n",
    "s_area  = pd.Series([295.2, 424.0, 170.3, 28.3, 250.5, 119.3, 695.7, 110.8, 184.7], index=['AZ', 'CA', 'FL', 'HI', 'MI', 'PA', 'TX', 'VA', 'WA'])  # thousand km^2\n",
    "s_warea = pd.Series([1.0,   20.5,  31.4,  11.7, 104.1, 3.4,   19.1,  8.5,   12.5],  index=['AZ', 'CA', 'FL', 'HI', 'MI', 'PA', 'TX', 'VA', 'WA'])  # thousand km^2\n",
    "\n",
    "d = {'area_water'  : s_warea, \n",
    "     'population'  : s_popu,\n",
    "     'area_total'  : s_area\n",
    "     \n",
    "    }\n",
    "df = pd.DataFrame(d)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.149899Z",
     "start_time": "2019-08-05T07:37:42.145891Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 1. Mean function >\n",
      "The average area and population:\n",
      " AZ    101.033333\n",
      "CA    161.266667\n",
      "FL     74.100000\n",
      "HI     13.810000\n",
      "MI    121.510000\n",
      "PA     45.166667\n",
      "TX    247.566667\n",
      "VA     42.566667\n",
      "WA     68.166667\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 1. Check average area and population\n",
    "df_mean = df.mean(axis = 1)\n",
    "print (\"< 1. Mean function >\")\n",
    "print (\"The average area and population:\\n\", df_mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.156048Z",
     "start_time": "2019-08-05T07:37:42.151584Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 2. Min function >\n",
      "The min area and population:\n",
      " area_water     1.00\n",
      "population     1.43\n",
      "area_total    28.30\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 2. Check minimum area and population\n",
    "df_min = df.min(axis = 0)\n",
    "print (\"< 2. Min function >\")\n",
    "print (\"The min area and population:\\n\", df_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.162175Z",
     "start_time": "2019-08-05T07:37:42.157668Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 3. Max function >\n",
      "The max area and population:\n",
      " area_water    104.1\n",
      "population     39.3\n",
      "area_total    695.7\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 3. Check maximum area and population\n",
    "df_max = df.max(axis = 0)\n",
    "print (\"< 3. Max function >\")\n",
    "print (\"The max area and population:\\n\", df_max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.169048Z",
     "start_time": "2019-08-05T07:37:42.165024Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 4. Median function >\n",
      "The median area and population:\n",
      " area_water     12.50\n",
      "population      9.93\n",
      "area_total    184.70\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 4. Check median area and population\n",
    "df_median = df.median(axis = 0)\n",
    "print (\"< 4. Median function >\")\n",
    "print (\"The median area and population:\\n\", df_median)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.175558Z",
     "start_time": "2019-08-05T07:37:42.170815Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 5. Std function >\n",
      "The standard deviation of area and population:\n",
      " area_water     31.588320\n",
      "population     12.100559\n",
      "area_total    202.207140\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# 5. Check standard deviation of area and population\n",
    "df_std = df.std(axis = 0)\n",
    "print (\"< 5. Std function >\")\n",
    "print (\"The standard deviation of area and population:\\n\", df_std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-05T07:37:42.184059Z",
     "start_time": "2019-08-05T07:37:42.177296Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "< 6. Correlation function >\n",
      "The correlation between area and population:\n",
      "             area_water  population  area_total\n",
      "area_water    1.000000    0.024941    0.077453\n",
      "population    0.024941    1.000000    0.709171\n",
      "area_total    0.077453    0.709171    1.000000\n"
     ]
    }
   ],
   "source": [
    "# 6. Check correlation between columns\n",
    "df_corr = df.corr()\n",
    "print (\"< 6. Correlation function >\")\n",
    "print (\"The correlation between area and population:\\n\", df_corr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# <span style=\"color:#FF8B33\">Exercise 3 (10 mins break)</span> \n",
    "Open `Week1 - Exercise 3.ipynb` and complete the exercises."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch3.7",
   "language": "python",
   "name": "pytorch"
  },
  "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.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}