CE_UQ_intro_to_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro to Python programming\n",
    "**Author: Audrey Olivier**\n",
    "\n",
    "### What is a Jupyter notebook?\n",
    "\n",
    "A Jupyter notebook is a web-based interactive computing platform. In simple terms it's a file (.ipynb extension) that can combine code, equations, text, visualizations etc. This current notebook presents a quick intro to Python.\n",
    "\n",
    "Each block in a notebook is called a cell; there are two types of cells, Markdown and Code. Each cell can be run independently. Let's go through the various icons in the taskbar at the top:\n",
    "- save notebook,\n",
    "- `+` is used to add a cell,\n",
    "- cut cells by clicking on the ✄ icon,\n",
    "- you can copy selected cells by clicking on the 4th icon, then paste them by clicking on the 5th icon,\n",
    "- the arrows allow you to skip between cells,\n",
    "- clicking run allows you to run the cell you are currently in, i.e., perform computations written in that cell,\n",
    "- the stop button stops computations currently running,\n",
    "- the last two buttons allow you to restart the kernel / restart and re-run. The kernel is the computational engine, when you re-start it all variables that were in memory are deleted.\n",
    "\n",
    "### Python as a basic calculator\n",
    "\n",
    "The command *a=2* defines variable *a* and assigns it the value 2. You can print the value of variable *a* using the command *print(a)*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "b = 3\n",
    "c = 2 + 3\n",
    "print(a)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a cell has been run, the variables defined in it are saved in memory and can be used in other cells. Be careful about that. In order to delete these variables from memory, you need to re-start the kernel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5\n"
     ]
    }
   ],
   "source": [
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic operations with numbers: `+, -, *, /`. Then ` ** ` means exponent. \n",
    "\n",
    "Use `#` to comment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4\n",
      "8\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "a, b = 2, 4\n",
    "print(a, b)\n",
    "\n",
    "c = a * b\n",
    "d = a ** b\n",
    "print(c)\n",
    "print(d)\n",
    "\n",
    "# this line is a comment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python datatypes and structures\n",
    "\n",
    "Main data types:\n",
    "- integer *int*, example: `2`\n",
    "- float *float*, example: `2.0` or `23.9`\n",
    "- string *str*, collection of characters, example `student 1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "a = 1   # this is an integer\n",
    "b = 1.2   # this is a float\n",
    "c = 'hello'   # this is a string\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also defines other data structures such as:\n",
    "- `lists`: a list is an ordered collection of items, usually used to group items of the same type, example: `[2, 3, -1, 5]`.\n",
    "- `tuples`: a tuple is an ordered collection of items, immutable, i.e. cannot be modified after creation, it is often used to group items of different types, e.g. (2, 0.1, 'hello').\n",
    "- `dictionaries`: unordered data types, using key/value pairs, usually fast for searching for an item.\n",
    "\n",
    "Items within a list / tuple are found via their index. Careful: python indexing starts at 0!!!! The last item is found via its index -1, one before last is indexed -2 and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "2\n",
      "-1\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "my_list = [2, 3, -1, 5]\n",
    "print(type(my_list))\n",
    "\n",
    "print(my_list[0])    # this is the first item in the list\n",
    "print(my_list[2])    # this is the 3rd item in the list\n",
    "print(my_list[-1])    # this is the last item in the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Several items can be returned via slicing, i.e., `my_list[start_index:end_index]` returns a list with elements starting at start_index (included) and finishing at end_index (NOT included!!!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, -1]\n",
      "[2, 3, -1]\n",
      "[3, -1, 5]\n"
     ]
    }
   ],
   "source": [
    "print(my_list[1:3])     # items after and including index 1 / before and not including index 3\n",
    "print(my_list[:3])    # all items before and not including index 3\n",
    "print(my_list[1:])    # all items after and including index 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also defines other data structures that will be of less use for this course but are worth knowing about:\n",
    "- tuple: ordered collection of items, immutable, i.e. cannot be modified after creation, often used to group items of different types, example: `(2, 0.1, 'hello')`,\n",
    "- dictionary: unordered key/value pairs, easy to search, example: `{'John': 16, 'Eva': 31, 'Maelys': 5}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "0.1\n",
      "(0.1, 'hello')\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (2, 0.1, 'hello')\n",
    "print(type(my_tuple))\n",
    "\n",
    "print(my_tuple[1]) \n",
    "print(my_tuple[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Differences between lists and tuples:\n",
    "- lists usually contain items of the same type (even though it is not a requirement),\n",
    "- lists are created using brackets while tuples are created using parentheses,\n",
    "- tuples are immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, -1, 5]\n",
      "[2, 4, -1, 5]\n"
     ]
    }
   ],
   "source": [
    "my_list = [2, 3, -1, 5]\n",
    "print(my_list)\n",
    "my_list[1] = 4    # you can modify the list\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 0.1, 'hello')\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-d6863f5e1bd8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmy_tuple\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'hello'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_tuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m4\u001b[0m    \u001b[0;31m# this line of code fails because a tuple cannot be modified after creation\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "my_tuple = (2, 0.1, 'hello')\n",
    "print(my_tuple)\n",
    "my_tuple[1] = 4    # this line of code fails because a tuple cannot be modified after creation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are unordered data types, i.e., they do not work with indexing. Instead they work via key/value pairs. The next cell defines a dictionary that stores the age of 3 people: the key is the person's name, the value is their age."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31\n"
     ]
    }
   ],
   "source": [
    "my_dict = {'John': 16, 'Eva': 31, 'Maelys': 5}\n",
    "# The age of each person can be accessed using the key, i.e., the person's name\n",
    "print(my_dict['Eva'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(31, 'F')\n"
     ]
    }
   ],
   "source": [
    "# This dictionary stores the age and gender of the person\n",
    "my_dict = {'John': (16, 'M'), 'Eva': (31, 'F'), 'Maelys': (5, 'F')}\n",
    "print(my_dict['Eva'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a block of code which only runs when it is called. You can pass data, known as parameters, into a function. A function can return data as a result. \n",
    "\n",
    "In Python a function is defined using the def keyword. In order to call the function, write the function name with parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a function that prints \"hello world!\"\n",
    "# note that nothing gets printed when you run this cell, the function gets created but it is not run\n",
    "\n",
    "def my_first_function():\n",
    "    print(\"hello world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!\n"
     ]
    }
   ],
   "source": [
    "# call the function to execute the code inside\n",
    "my_first_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function can have data as input (called parameters), and data as output (use the keyword `return`). Example: create a function that adds two numbers, then call it for various values of the inputs x, y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_addition(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "z = do_addition(x=1, y=2)\n",
    "print(z)\n",
    "\n",
    "z = do_addition(x=2, y=2)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Flow control: \"for\" loops and \"if/elif/else\" statements\n",
    "\n",
    "Sometimes you need to repeat a process several times, you can do it easily using a `for` loop. Example: compute the square of all numbers from 0 to 4, and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "for i in [0, 1, 2, 3, 4]:\n",
    "    print(i ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `range` function is pretty helpful in this situation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can easily create lists in this fashion, using so-called *list comprehensions*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "squared_numbers = [i ** 2 for i in range(5)]\n",
    "\n",
    "print(type(squared_numbers))\n",
    "print(squared_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other cases, you want to perform different actions based on the value of the input. For example, create a function that returns 0 if the input x is less than 0 or greater than 1, and 1 otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def step_function(x):\n",
    "    if x < 0 or x > 1:\n",
    "        z = 0\n",
    "    else:\n",
    "        z = 1\n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0\n"
     ]
    }
   ],
   "source": [
    "z1 = step_function(x=0.5)\n",
    "z2 = step_function(x=1.5)\n",
    "print(z1, z2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0\n"
     ]
    }
   ],
   "source": [
    "# you can also write it with an elif statement (you can have as many elif statements as you need)\n",
    "def step_function_v2(x):\n",
    "    if x < 0:\n",
    "        z = 0\n",
    "    elif x > 1:\n",
    "        z = 0\n",
    "    else:\n",
    "        z = 1\n",
    "    return z\n",
    "\n",
    "z1 = step_function_v2(x=0.5)\n",
    "z2 = step_function_v2(x=1.5)\n",
    "print(z1, z2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python packages\n",
    "\n",
    "A Python package is a piece of Python code that has been developed and usually serves a given functionality. For instance:\n",
    "- `numpy` and `scipy` are the main Python packages for scientific computing (they offer a comprehensive list of mathematical functions, random number generators, linear algebra routines, statistical tools etc),\n",
    "- `matplotlib` and `seaborn` are packages for plotting,\n",
    "- `pandas` is a package for reading and manipulating tabular data,\n",
    "- `statsmodel` is a package for statistical modeling,\n",
    "- `scikit-learn` is a package for machine learning, it implements regression tools, Gaussian processes, neural networks, support vector machine etc.\n",
    "- and many many more.\n",
    "\n",
    "Importing packages allows you to use code that has already been developed, no need to re-invent the wheel.\n",
    "\n",
    "In order to use a package, you need to first install it (you can do it from the command prompt or the Anaconda-Navigator), then import it using the `import` commmand, and use its functionalities. For instance, the numpy package contains a function called sum that sums the elements of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "import numpy as np    # import the numpy package\n",
    "z = np.sum([1, 2, 3])    # call the sum function of the numpy package\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numpy package also defines a new data type called a `ndarray`. Most often used are 1D arrays and 2D arrays (i.e., matrices)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2, 3])    # creates a 1D array \n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n"
     ]
    }
   ],
   "source": [
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "y = np.array([[1, 2], [3, 4], [5, 6]])    # this is a 2D array (matrix) with 3 rows and 2 columns\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you apply a function to a ndarray, it is applied to every element in the array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[6 7 8]\n",
      "[1 4 9]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2, 3])\n",
    "print(x)\n",
    "\n",
    "y = x + 5\n",
    "print(y)\n",
    "\n",
    "z = x ** 2\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib package for plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt    # only import the module pyplot of the matplotlib package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "[ 0  1  4  9 16]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(5)     # same as range but creates a 1D array\n",
    "y = x ** 2    # this applies the function to every item in the ndarray\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x180 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(4, 2.5))    # create the figure and axes\n",
    "ax.plot(x, y, marker='+', color='red', linestyle='--')     # tell it what to plot on it and how\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('My first plot')\n",
    "plt.show()     # show the figure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "os package to work with files, directories and so on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/audreyolivier/Documents/USC/Courses/CE599UQ/Content_2022/Notebooks\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "cwd = os.getcwd()    # this is the current directory you are in\n",
    "print(cwd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pandas package to open files containing structured data (i.e., csv or excel files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/audreyolivier/Documents/USC/Courses/CE599UQ/Content_2022/Notebooks/data_rainfall_runoff.xlsx\n"
     ]
    },
    {
     "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>Storm nb</th>\n",
       "      <th>X = Precipitation (in)</th>\n",
       "      <th>Y = Runoff (in)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1.11</td>\n",
       "      <td>0.52</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1.17</td>\n",
       "      <td>0.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>1.79</td>\n",
       "      <td>0.97</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>5.62</td>\n",
       "      <td>2.92</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>1.13</td>\n",
       "      <td>0.17</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Storm nb  X = Precipitation (in)  Y = Runoff (in)\n",
       "0         1                    1.11             0.52\n",
       "1         2                    1.17             0.40\n",
       "2         3                    1.79             0.97\n",
       "3         4                    5.62             2.92\n",
       "4         5                    1.13             0.17"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "filename = cwd + '/data_rainfall_runoff.xlsx'\n",
    "print(filename)\n",
    "\n",
    "data = pd.read_excel(filename, header=0)    \n",
    "# the first line of the excel file (index 0) is a header containing column names\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Storm nb' 'X = Precipitation (in)' 'Y = Runoff (in)']\n"
     ]
    }
   ],
   "source": [
    "print(data.columns.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQgAAAC1CAYAAACj1WHgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAOq0lEQVR4nO3de6wc5X3G8e9TY8eOsU0UW8TG2AeUhArR1CQHlMZtdUTTiDaUXFSVIuLi0NZqShMi0rRNpTZpo6pKlaYlQbSycAS4iChckgBpI1ziS51gwMc+gGtXSuVglZbIJsGAG5eA+fWPmbXX652dWZ+ZMzu7z0da7ezuzOzPl3n2nXfemVFEYGbWzU/VXYCZDS4HhJllckCYWSYHhJllckCYWSYHhJllOqOqFUuaC2wDXpd+zz0R8eleyyxevDjGxsaqKsnMMkxOTj4XEUs6368sIICXgcsi4oik2cB2Sf8SETuyFhgbG2Pnzp0VlmRm3Ug60O39ygIikhFYR9KXs9OHR2WZNUilfRCSZkmaAg4CmyLi0Sq/z8zKVWlARMSxiFgFLAculXRR5zyS1knaKWnnoUOHqizHbHRMTCSPaZqRoxgRcRjYAlze5bP1ETEeEeNLlpzSR2JmNaryKMYS4JWIOCxpHvBu4HNVfZ+ZcaLVsHXrya+3bDmt1VV5FGMpcLukWSQtla9GxIMVfp+ZlazKoxhPAhdXtX4z66LVUphmy6HFIynNLFOVuxhmVpdpthxa3IIws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPL5IAws0wOCDPLdEbRGSW9AVgGHAWejojXKqvKzAZCz4CQtAi4HrgamAMcAuYCZ0vaAdwSEZszlj0XuAN4E/AasD4ibiqxdjOrWF4L4h6SjfwXIuJw+weS3gGskXR+RGzosuyrwCciYpekBcCkpE0RsbeUys2scj0DIiJ+ucdnk8Bkj8+fBZ5Np1+StA84B3BAmDVEP30Q5wAr25eJiG0Flx0DLgYe7a88M6tToYCQ9DngKpJf/2Pp2wHkBoSkM4F7gY9HxItdPl8HrANYsWJFsarNbEYUbUG8H7ggIl7uZ+WSZpOEw50RcV+3eSJiPbAeYHx8PPpZv5lVq+g4iP3A7H5WLEnABmBfRHyh38LMrH5FWxA/BqYkPQwcb0VExMd6LLMaWAM8JWkqfe9PI+KfT6tSM5txRQPi/vRRWERsB9R3RWY2MAoFRETcXnUhZjZ48kZSfjUifkPSUyRHLU4SEW+rrDIzq11eC+KG9PmKqgsxs8GTFxA/AIiIA1kzSFJE+PCk2emYmEiet2yps4pMeYc5N0v6qKSTRjBJmiPpMkm3A9dWV56Z1SmvBXE5cB1wl6TzgMMkZ3POAh4C/i4ipnosb2bdtFoOW7ee/HrAWhJ5J2v9H3ALcEs6KnIxcLTzzE4zG06FT9aKiFdIz840s2lqtRQGtOXQ4kvOmVmmvHEQr+v3BC0z68OAthxa8loQjwBI2jgDtdgomJg40ay2gZfXBzFH0rXAuyR9sPPDrFO4zWw45AXE7wHXAGcBv9bxWQAOCCumIYf17GR5AbE0Ij4iaXd6YRczGyF5AfEp4G6SloQDwk5fQw7r2cnyAuKHkjYD50k65XoQEXFlNWWZ2SDIC4j3Am8HNgJ/W305NvTccmiUvKHWPwF2SHpXRBxKb4ATEXFkZsozszoVHUl5tqTdwB5gr6RJSRdVWJeZDYCiAbEeuDEiVkbECuATuNPSbOgVDYj57TfpjYgtwPxKKjKzgVH0bM79kv6MpLMS4EPA96spycwGRdEWxHXAEpKRk19Lpz9cVVFmNhiKXvb+eaDXTXLMbAgVvXnvW4E/BMY4+e7el1VTlpkNgqJ9EHcD/wjcyom7e1sTeGizTUPRgHg1Iv6h0krMbOAUDYgHJP0+SQdl+817f1RJVTZ9Pr3aSlA0IFr3vvhk23sBnF9uOWY2SIoexTiv6kKsZD692kpQ9CjGb3V7PyLuKLccMxskRXcxLmmbngv8ErALcEAMuryWg1sY1kPRXYyPtr+WtIgTw67NbEgVvrNWhx8DbymzEJthPsphBRTtg3iA5KgFJOdvXEgyeMrMhljRFsTn26ZfBQ5ExDMV1GMzpY6jHG6lNE7RPoit7a8lzZJ0TUTcmbWMpC8DVwAHI8JXnzJroLx7cy4ErgfOAe4HNqWvPwlMAZkBAdwG3MywHukYll/DmWw5uL+jcfJaEBuB50nu0fk7JMEwB3hfREz1WjAitkkaK6HG4eKNwxokLyDOj4ifAZB0K/AcsCIiXiqrAEnrgHUAK1asKGu11fGvYf88qrOx8gLildZERByT9P0ywyFd73rSC+COj49HzuzN5WCxBsoLiJ+V9GI6LWBe+lok98dYWGl1g8i/hqfPf1eNk3fjnFkzVcjQc7BYA53uSMpcku4CJoDFkp4BPh0RG6r6vhnnDdxGQGUBERFXV7XuRnOwWIMUvey9mY0gB0Q3ExMn+gqatG6zkjkgrD8OuJFSWR9EI1U5VsHjIKyBHBB5pqaSjXnUN2QH3EhyQLTrNlahrOa0x0FYAzkgsrRaDp2/mC2jtoE74EbScAVEWf95y2w5dFu3WUMMV0CUqfMXs2XU98FH7c874oYjIMrsQBvVDd+si+EIiLJMTCR9D6tWnXivMygcIDZChiMgyuhAa4XDCy8kLREHgdmQBMR0OxTbw6GlsyXR4sCwETIcAdEynY131aoTfRiLFiWvHQY24podEGV1TrbvorRaDg4HM5+sdYomhoNPoLKKNLsFUfbovqYFg1nFmh0QnUbtyINPoLKKDUdAtDaIs85Knr2hmJViOAKiFQitw5RTPW/6NTx8ApVVbDgCojMQWkHhDcdsWoYjIFoDmrZu7T3fsHIAWkWaFxDdWgWdfRCtwPCGYzYtzQuIXroNjTaz09acgChySM8tBrNSDc9ISo8mNCtdc1oQPqRnNuOaExBZyh5N6AAyO655AeEN12zGNC8gOnUe4pxuy8HnNZgd1/yA6Bxm7Q3brDTND4iyuBPU7BTNDwhv2GaVaX5AlM0BY3bc8ASEN2yz0g3PSEozK50DwswyOSDMLJMiou4ajpN0CDhQYNbFwHMVl1OmJtXbpFrB9ZZlZUQs6XxzoAKiKEk7I2K87jqKalK9TaoVXG/VvIthZpkcEGaWqakBsb7uAvrUpHqbVCu43ko1sg/CzGZGU1sQZjYDGhUQkr4s6aCkPXXXkkfSuZI2S9on6d8l3VB3Tb1ImivpMUlPpPX+Rd015ZE0S9JuSQ/WXUsRkp6W9JSkKUk7666niEbtYkj6ReAIcEdEXFR3Pb1IWgosjYhdkhYAk8D7I2JvzaV1JUnA/Ig4Imk2sB24ISJ21FxaJkk3AuPAwoi4ou568kh6GhiPiEEcB9FVo1oQEbEN+FHddRQREc9GxK50+iVgH3BOvVVli8SR9OXs9DGwvx6SlgPvBW6tu5Zh1qiAaCpJY8DFwKP1VtJb2mSfAg4CmyJikOv9e+CPgNfqLqQPATwkaVLSurqLKcIBUTFJZwL3Ah+PiBfrrqeXiDgWEauA5cClkgZyN07SFcDBiJisu5Y+rY6ItwO/Alyf7jIPNAdEhdJ9+XuBOyPivrrrKSoiDgNbgMtrLiXLauDKdJ/+K8Blkv6p3pLyRcT/pM8Hga8Bl9ZbUT4HREXSTr8NwL6I+ELd9eSRtETSWen0PODdwH/UW1V3EfGpiFgeEWPAbwLfjogP1VxWT5Lmp53VSJoPvAcY+KNxjQoISXcBjwAXSHpG0m/XXVMPq4E1JL9uU+njV+suqoelwGZJTwKPk/RBNOLwYUOcDWyX9ATwGPDNiPhWzTXlatRhTjObWY1qQZjZzHJAmFkmB4SZZXJAmFkmB4SZZXJANISkY+mh0j2S7pb0+hLWOS7piznzLJN0Tzq9qsih2s75JF0p6U+mW2+6rnmStqbDwo/XlrPMv0p6QxnfP2p8mLMhJB2JiDPT6TuByfYBWOnALEVEZecmSFpLcjbiH5Qx32nWcD1wRkTc1Mcy1wLLI+Kvyq5n2LkF0Uz/BrxZ0lh6vYlbgF3AuZLeI+kRSbvSlkYrVC6R9N30eg+PSVogaaJ1LQVJn5G0UdK3JX1P0u+m74+lrZY5wF8CV6UtmaskXZquc3f6fEHGfGsl3Zyub6WkhyU9mT6vSN+/TdIX0/Xsl/TrGX/2a4BvtNeWTq+VdJ+kb6X1/03bMvcDV5f6LzAqIsKPBjyAI+nzGSQbyEeAMZKzGd+ZfrYY2EZyXQeAPwb+HJgD7AcuSd9fmK5nAngwfe8zwBPAvHQ9/wUsS79jTzrPWuDmtpoWkvyaQzI0+96M+Y6/Bh4Ark2nrwO+nk7fBtxN8qN1IfCfXf4O5gA/aHvdWdt+YBEwl+T+Kue2zfs94I11/zs27TE8N+8dfvPSU7EhaUFsINmAD8SJi7q8k2Tj+k6yx8Ec0qHpwLMR8ThApGeVpvO0+0ZEHAWOStpMcjLRVOdMbRYBt0t6C8mpzLML/Dl+DvhgOr0RaP+l/3oku0h7JZ3dZdnFwOEe6344Il4AkLQXWEkSdJCcwr4M+GGBGi3lgGiOo5Gcin1cuoH/b/tbJOdQXN0x39sodvGXznnylvkssDkiPpBe82JLge/o9Z0vt02fkl7AUZLWQZb25Y9x8v/vueny1gf3QQyXHcBqSW8GkPR6SW8lOStzmaRL0vcXSOr24/A+JdemfCPJ7sfjHZ+/BCxoe70I+O90em2P+dp9l+QMTEj6E7YX+HMBEBHPA7Mk9QqJU6QduG8Cnu5nOXNADJWIOESyod6VnpW5A/jpiPgJcBXwpfRswk10/yV+DPhmutxnI71+QZvNwIWtzkeS3YO/lvQdYFaP+dp9DPhwWt8aoN+L+T4E/Hyfy7wD2BERr/a53MjzYU4DkqMYJB2hn6+7ll4kXQzcGBFr+ljmJuD+iHi4usqGk1sQ1igRsZvkuhWzcmc+YY/D4fS4BWFmmdyCMLNMDggzy+SAMLNMDggzy+SAMLNMDggzy/T/i2nvzQ7FNgYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 288x180 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot runoff as function of precipitation\n",
    "fig, ax = plt.subplots(figsize=(4, 2.5))\n",
    "ax.scatter(data['X = Precipitation (in)'], y=data['Y = Runoff (in)'], marker='+', color='red')\n",
    "ax.set_xlabel('Precipitation (in)')\n",
    "ax.set_ylabel('Runoff (in)')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "End note: Google is your best friend!!!"
   ]
  },
  {
   "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
}