01-Python-basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Tutorial I: Python Basics\n",
    "\n",
    "We focus on presenting the ***basics*** of Python for scientific computing. \n",
    "This is intended only to help break down the barriers of entry into using Python and some of the basic tools commonly used in scientific computing. \n",
    "\n",
    "For more thorough (and advanced) tutorials over some of the topics we are touching upon in these lectures, we recommend bookmarking https://docs.python.org/3/tutorial/index.html for more details on Python basics (e.g., data structures, conditionals, and loops) and http://scipy.org/ for more details on useful libraries that unlock the power of Python for scientific computing.\n",
    "\n",
    "We are using Jupyter Notebooks (http://jupyter.org/) in these tutorials. \n",
    "More notebook-oriented tutorials are also available online."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Objectives\n",
    "\n",
    "- Understand some of the more commonly used data types.\n",
    "\n",
    "\n",
    "- Assign values to variables and perform basic *arithmetic* operations.\n",
    "\n",
    "\n",
    "- Understand what a library is, and what libraries are used for.\n",
    "\n",
    "\n",
    "- Load a Python library and use its functions.\n",
    "\n",
    "\n",
    "- Perform operations on arrays of data.\n",
    "\n",
    "\n",
    "- Display simple graphs via `matplotlib`\n",
    "\n",
    "\n",
    "- Understand how to read error messages to do some basic debugging with the mini-exercises.\n",
    "\n",
    "\n",
    "Along the way, we will use some simple ***built-in functions within Python.*** \n",
    "In particular, we will make use of the functions `print`, `type`, and `range` early on in this tutorial. \n",
    "Take a moment and review some of the documentation on these available at https://docs.python.org/3/library/functions.html."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Integers, floats, and casting:\n",
    "\n",
    "***Key Points:***\n",
    "\n",
    "- Integers are whole numbers that are specified without decimals. Examples are 1, 2, 0, and -10. \n",
    "\n",
    "\n",
    "\n",
    "- Floats (or floating point numbers) are finite representations of real numbers with a finite number of decimal places. Examples are 1.1, 2.3, 0.07, and -10.0.\n",
    "\n",
    "\n",
    "- An arithmetic operation will **cast** the result as either the type of the ***most general variable used in the operation*** or as the type of ***output generally expected from the operation***, so whether or not we worry about casting depends upon what result we desire from the operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Here, we define some variables used below.\n",
    "one_int = 1\n",
    "\n",
    "one_float = 1. #no need to do 1.0\n",
    "\n",
    "two_int = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# We can print the types of variables using the print and type commands\n",
    "\n",
    "print() #This prints a blank line. \n",
    "# Using spaces and blank lines when printing makes output more readable\n",
    "print( 'one_int is of type', type(one_int), \n",
    "       'and one_float is of type', type(one_float) )\n",
    "#Breaking up long function calls across many lines helps readability\n",
    "\n",
    "print()\n",
    "print( 'The variable two_int is type ', type(two_int) )\n",
    "\n",
    "print()\n",
    "print( 'The variable defined by one_int+two_int is type ', \n",
    "       type(one_int+two_int) )\n",
    "\n",
    "print()\n",
    "print( 'The variable defined by one_int/two_int is type ', \n",
    "       type(one_int/two_int) )\n",
    "\n",
    "print()\n",
    "print( 'The variable defined by one_float/two_int is type ', \n",
    "       type(one_float/two_int) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we observe the output of typical division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print()\n",
    "print( 'one_int/two_int =', one_int, '/', two_int, '=',  one_int/two_int )\n",
    "\n",
    "three = 3 #What type is this?\n",
    "\n",
    "print()\n",
    "print( 'two_int/three =', two_int, '/', three, '=', two_int/three )\n",
    "\n",
    "neg_one = -1.0 #What type is this?\n",
    "\n",
    "print()\n",
    "print( 'neg_one/two_int =', neg_one, '/', two_int, '=', neg_one/two_int )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The command `//` performs ***integer division***, which is sometimes claled ***floor division*** because it *rounds down to the nearest integer*. \n",
    "This is useful in a variety of settings. \n",
    "\n",
    "Recall that an arithmetic operation will **cast** the result as either the type of the ***most general variable used in the operation*** or as the type of ***output generally expected from the operation***. \n",
    "Let's observe the behavior of `//` below when the inputs are both integers and in cases where at least one input is a float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print()\n",
    "print( 'one_int//two_int =', one_int, '//', two_int, '=', one_int//two_int )\n",
    "\n",
    "print()\n",
    "print( 'one_float//two_int =', one_float, '//', two_int, '=',  one_float//two_int )\n",
    "\n",
    "print()\n",
    "print( 'neg_one//two_int =', neg_one, '//', two_int, '=', neg_one//two_int )\n",
    "\n",
    "print()\n",
    "print( 'two_int//three =', two_int, '//', three, '=', two_int//three )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini-exercise 1: Reading error messages and fixing the code\n",
    "\n",
    "### The code block below will not execute correctly. Try running it and read the error messages as you systematically fix it to define and print the integer 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "four = \n",
    "\n",
    "print( 'The variable four =', four, 'is of type', type() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### Specifying casting:\n",
    "\n",
    "***Key Points:***\n",
    "\n",
    "- We can specify how we want an integer or float to be treated to allow for greater control in the code. This is also referred to as **casting** whenever we specify that a variable should be treated as a different type from what it is in a particular context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "two = one_int + one_float\n",
    "\n",
    "print()\n",
    "print( 'two =', two, 'is of type ', type(two) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "two = one_int + int(one_float)\n",
    "\n",
    "print()\n",
    "print( 'Two =', two, 'is now of type', type(two) )\n",
    "\n",
    "print()\n",
    "print( 'Did one_float change type?', type(one_float) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = -3.7\n",
    "\n",
    "print()\n",
    "print( 'x =', x, 'is of type', type(x) )\n",
    "\n",
    "print()\n",
    "print( 'int(x) =', int(x), 'is an integer' )\n",
    "\n",
    "print()\n",
    "print( 'We can also change integers to floats.' )\n",
    "\n",
    "print()\n",
    "print( 'float(ont_int) =', float(one_int), 'defines a float.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini-exercise 2\n",
    "\n",
    "Fill in the missing pieces of the code cell below to define variable `y` as a floating point number version of `int(x)` and print both `y` and `x`.\n",
    "Can you explain any differences?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 1.7583\n",
    "\n",
    "y = int(float(x))\n",
    "\n",
    "print()\n",
    "print( 'y =', y, 'is of type', type(), \n",
    "       'and x =', , 'is of type', type() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How do we raise a number to a power?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pt_one = 0.1\n",
    "\n",
    "print()\n",
    "print( '0.1 cubed =', pt_one**3 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complex valued variables\n",
    "\n",
    "***Key points:***\n",
    "\n",
    "- Python uses the electrical engineering $j$ convention.\n",
    "\n",
    "\n",
    "- The letter `j` can still be used as a variable for another number with no issues."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "j = 3.68439876 #Clearly not the square root of negative one\n",
    "\n",
    "alpha = 3.0-4.0j #3.0 - 4.0j is not equal to 3.0-4.0*j, see below\n",
    "\n",
    "print()\n",
    "print( alpha, 'is of type', type(alpha) )\n",
    "\n",
    "print()\n",
    "print( alpha, ' has length', abs(alpha) )\n",
    "\n",
    "print()\n",
    "print( 'If j =', j, 'then 3.0-4.0*j =', 3.0-4.0*j )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings:\n",
    "- Many binary operations do not apply to strings, but one can do + to concatenate two strings into one. \n",
    "***Concatenation is particularly useful when creating filenames for saving/loading data in loops.***\n",
    "\n",
    "\n",
    "- We can also create multiples of the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "text = 'Hello'\n",
    "text += ', World : ' #This is the same as text = text + ', World : '\n",
    "\n",
    "print()\n",
    "print( text )\n",
    "\n",
    "text *= 3 #This is the same as text = 3*text\n",
    "print()\n",
    "print( text )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Due to casting, printing a variable without its type may lead you into thinking a variable is of a different type than it actually is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "one_str = '1'\n",
    "\n",
    "print()\n",
    "print( one_str, 'is of type', type(one_str))\n",
    "\n",
    "one_int = int(one_str)\n",
    "\n",
    "print()\n",
    "print( one_int, 'is of type', type(one_int))\n",
    "\n",
    "one_float = float(one_str)\n",
    "\n",
    "print()\n",
    "print( one_float, 'is of type', type(one_float))\n",
    "\n",
    "one_float_str = str(one_float)\n",
    "\n",
    "print()\n",
    "print( one_float_str, 'is of type', type(one_float_str))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini-exercise 3\n",
    "\n",
    "Fill in the missing pieces of the code below to create and print the string variable `str_var`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 3.14159\n",
    "\n",
    "x_str =  #x cast as a string\n",
    "\n",
    "x_int_str =  #x cast as an int and then cast as a string\n",
    "\n",
    "str_var = x_str + ' is a reasonable approximation of pi.'\n",
    "\n",
    "str_var += ' ' + x_int_str + ' is a terrible approximation of pi.'\n",
    "\n",
    "print()\n",
    "print(str_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Who's Who in Memory (the first magic command)\n",
    "- IPython \"magic\" commands are conventionally prefaced by %. ***If you run these commands in a non-interactive Python environment, then they will not work. You typically only include these commands as you are debugging code in an interactive environment such as an IPython terminal or a Jupyter Notebook.***\n",
    "\n",
    "\n",
    "- The `%whos` command is particularly useful for debugging as it returns all variables in memory along with their type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%lsmagic #Lists all available magic commands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Lists\n",
    "\n",
    "***Key points:***\n",
    "\n",
    "- Lists are ***ordered arrays*** of almost any type of variable or mixed-types of variables you can think of using in Python. You can even make a ***list of lists***. You use lists when the order matters in the code, e.g., when you plan on looping through the elements of the list in some ordered way. Other popular ways to handle data structures include dictionaries and sets (e.g., see https://docs.python.org/3/tutorial/datastructures.html).\n",
    "\n",
    "\n",
    "- Indexing ***starts at zero***. This means that the first element of a list is indexed by a zero, the second element is indexed by 1, and so on. If it seems confusing at first, don't worry, you'll get use to it. This is also discussed below in greater detail when using arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "float_list = [1.0, 2.0, 3.0]  #list of floats  \n",
    "\n",
    "print()\n",
    "print( 'float_list = ', float_list )\n",
    "\n",
    "print()\n",
    "print( 'float_list*2 = ', float_list*2 ) #What do you think this should produce?\n",
    "\n",
    "print()\n",
    "print( 'float_list[0] = ', float_list[0] )\n",
    "\n",
    "print()\n",
    "print( 'float_list[0]*2 = ', float_list[0]*2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "int_list = list(range(1,20,2)) #build a list, start with 1, add 2 while less than 20\n",
    "\n",
    "print()\n",
    "print( 'int_list = ', int_list )\n",
    "\n",
    "print()\n",
    "print( '(type(int_list), type(float_list)) = ', (type(int_list), type(float_list)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "list_of_lists = [float_list, int_list] #build a list of lists\n",
    "\n",
    "print()\n",
    "print( 'mixed_list = ', list_of_lists)\n",
    "\n",
    "print()\n",
    "print( 'mixed_list[0] = ', list_of_lists[0] )\n",
    "\n",
    "print()\n",
    "print( 'mixed_list[0] = ', list_of_lists[1] )\n",
    "\n",
    "print()\n",
    "print( 'mixed_list[0][1] = ', list_of_lists[0][1] )\n",
    "\n",
    "print()\n",
    "print( 'mixed_list[1][2] = ', list_of_lists[1][2] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "conc_list = float_list + int_list #Concatenation of lists\n",
    "\n",
    "print()\n",
    "print( 'conc_list = ', conc_list )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A few quick notes about lists\n",
    "* While we can build a list of numbers, their group behavior does ***not*** match the individual behavior. For example, in the code above, `float_list*2` produces a list of floats that is not equal to the floats within the list multiplied by 2.\n",
    "\n",
    "\n",
    "* Below, we work with **numpy** *arrays* which are lists that behave more like vectors and matrices. Generally, if the objective is to do actual scientific computations on the lists that are like matrix or vector operations, then we want to use `numpy` arrays not lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing Packages (sometimes called Libraries), Subpackages, and Modules\n",
    "\n",
    "- A module is a single file of python code that is meant to be imported.\n",
    "\n",
    "\n",
    "- A package is a collection of Python modules under a common namespace (in computing, a namespace is a set of symbols that are used to organize objects of various kinds, so that these objects may be referred to by name). In practice one is created by placing multiple python modules in a directory with a special `__init__.py` module (file). \n",
    "\n",
    "\n",
    "- Unlike many scripting languages, Python follows the conventions of many compiled languages by accessing packages (libraries) via the **import** statement.  Three of the libraries you'll find yourself importing often are \n",
    "\n",
    "    - `numpy` (https://docs.scipy.org/doc/numpy/) \n",
    "    \n",
    "    - `scipy` (https://docs.scipy.org/doc/scipy/reference/)\n",
    "    \n",
    "    - `matplotlib` (http://matplotlib.org/). \n",
    "    \n",
    "There are several other libraries used commonly with Python when doing scientific computing, and the documentation at https://scipy.org/ is a particularly useful starting point.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy  #imports numpy as is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access a function or class in a library, the syntax is `libraryname.functioname(args)`.\n",
    "\n",
    "For example, to access the `sin` function within `numpy` and evaluate it at $\\pi$, we do the following,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print( numpy.sin(numpy.pi) )  #numpy.pi is a library constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also import a library and assign it a convenient nickname. ***This is how we typically do things.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "print( np.log(np.e) ) #np.e is also a library constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, you may just want to import a particular function or subpackage.\n",
    "\n",
    "Below, we use the `log` function from the `math` package and the `random` subpackage from `numpy` to generate a single sample from a normal distribution by taking the logarithm of a lognormal sample (see https://en.wikipedia.org/wiki/Log-normal_distribution for details). \n",
    "This is only meant to show how to combine multiple imported functions/subpackages. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from math import log #imports the (natural) log function from the math package, we could also just use np.log below\n",
    "\n",
    "from numpy import random #imports the random subpackage from numpy\n",
    "\n",
    "sample = log( random.lognormal() ) #generate one normal random sample\n",
    "\n",
    "print()\n",
    "print( sample )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python help\n",
    "If you are coding without internet activity and want to look something up about a Python library or function, then use the help command. Note that this will also provide information about where to find the proper documentation online in most cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "help(help)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini-exercise 4\n",
    "\n",
    "Fill in the missing pieces of the code below to import the `uniform` function from `numpy.random` as `runif` and print a single uniform random number between 0.0 and 1.0, and then print a single uniform random number between 9.0 and 10.0.\n",
    "\n",
    "You may it useful to first look at the documention on this function (https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.uniform.html). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from numpy.random import  as \n",
    "\n",
    "sample = runif(low=, high=) #generate one uniform random sample between 0.0 and 1.0\n",
    "\n",
    "print()\n",
    "print( sample )\n",
    "\n",
    "sample =  #generate one uniform random sample between 9.0 and 10.0\n",
    "\n",
    "print()\n",
    "print( sample )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cautionary Note On Importing\n",
    "You can avoid typing the library name or nickname altogether by importing everything as `*`, e.g., typing \n",
    "\n",
    "    import numpy as * \n",
    "    \n",
    "loads every subpackage and function within the `numpy` library into the current namespace.\n",
    "\n",
    "This is ***discouraged*** because it\n",
    "\n",
    "- provides the opportunity for namespace collisions (e.g., if you had a variable name pi prior to the import of `numpy`);\n",
    "\n",
    "\n",
    "- may be inefficient (e.g., if the number of objects imported is big);\n",
    "\n",
    "\n",
    "- does not explicitly document the origin of the variable/method/class, which provides a type of auto-documentation in the program that makes it easier for others to know what you are doing (and for you to know what you are doing when you look at your code weeks, months, or even years later)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy arrays (and why we use these more than lists)\n",
    "\n",
    "Numpy arrays are not just more efficient than lists, they are also more convenient when needing to do most numerical linear algebra (and much of computational science boils down to numerical linear algebra). \n",
    "You get a lot of vector and matrix operations for free, which means we can often avoid unnecessary work that would be required if we were to just use lists. \n",
    "They are also more memory efficient. \n",
    "While lists are more flexible, this flexibility comes with a heavy price in terms of memory and not being able to apply a lot of built-in functionality on the lists.\n",
    "\n",
    "\n",
    "We make heavy use of `numpy` arrays. Below are some examples of array constructions. \n",
    "***Pay attention to the number and location of square brackets used to define the dimensional inputs of the arrays.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "arr_1d = np.array( [1,2,3,4] )  #1D array (typically called a vector)\n",
    "\n",
    "arr_2d = np.array( [ [1,2],[3,4],[5,6] ] ) #2D array (sometimes called a matrix)\n",
    "\n",
    "arr_3d = np.array( [ [ [1,2,3], [4,5,6] ],[ [7,8,9],[10,11,12] ] ] ) #3D array\n",
    "\n",
    "print()\n",
    "print( 'arr_1d =\\n', arr_1d ) #Note the use of \\n in a string, which, when printed, creates a new line\n",
    "\n",
    "print()\n",
    "print( 'arr_2d =\\n', arr_2d )\n",
    "\n",
    "print()\n",
    "print( 'arr_3d =\\n', arr_3d )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once a numpy array is defined, we can investigate many of its attributes easily."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#the numpy array attribute \"shape\"\n",
    "print()\n",
    "print( 'The shape of arr_1d is', arr_1d.shape )\n",
    "\n",
    "print()\n",
    "print( 'The shape of arr_2d is', arr_2d.shape )\n",
    "\n",
    "print()\n",
    "print( 'The shape of arr_3d is', arr_3d.shape )\n",
    "\n",
    "#the numpy array attribute \"size\"\n",
    "print()\n",
    "print( 'The total number of components of arr_3d is', arr_3d.size )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini-exercise 5\n",
    "\n",
    "Fill in the code below to create a 2D array of shape (2, 3) and a 3D array of shape (1,2,3)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "my_array_2d = np.array( [ [],[] ] )\n",
    "\n",
    "print()\n",
    "print( 'my_array_2d =\\n', my_array_2d )\n",
    "\n",
    "print()\n",
    "print( 'The shape of my_array_2d is', my_array_2d.shape )\n",
    "\n",
    "my_array_3d = np.array( [ [ [],[] ] ] )\n",
    "\n",
    "print()\n",
    "print( 'my_array_3d =\\n', my_array_3d )\n",
    "\n",
    "print()\n",
    "print( 'The shape of my_array_3d is', my_array_3d.shape )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Casting the type of a `numpy` array.\n",
    "\n",
    "The `numpy` data type attribute `dtype` describes the type of data stored in `numpy` and it is cast as the ***minimal*** data type required to store all the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#the numpy attribute \"dtype\" describes the data type stored in the array\n",
    "print()\n",
    "print( 'The type of a numpy array is the minimal type required to hold all the data' )\n",
    "\n",
    "print()\n",
    "print( 'The data type of the original arr_3d is', arr_3d.dtype )\n",
    "\n",
    "#What happens if we change the last entry of arr_3d in the above code block to be 12.0?\n",
    "\n",
    "arr_3d = np.array( [ [ [1,2,3], [4,5,6] ],[ [7,8,9],[10,11,12.0] ] ] ) #3D array\n",
    "\n",
    "print()\n",
    "print( 'arr_3d =\\n', arr_3d )\n",
    "\n",
    "print()\n",
    "print( 'The data type of this new arr_3d is', arr_3d.dtype )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily re-cast the data in `numpy` arrays as different data types using the special `astype` function, which creates a copy of the specified array that are cast to a specified type.\n",
    "\n",
    "You may also specify the data type during the array creation call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print()\n",
    "print( 'A copy of arr_2d as a float \\n', arr_2d.astype(float) )\n",
    "\n",
    "print()   \n",
    "print( 'The arr_2d is still an integer array \\n', arr_2d, '\\n', arr_2d.dtype )\n",
    "\n",
    "print() \n",
    "print( 'Here is a copy of of arr_2d as a str array \\n', arr_2d.astype(str) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The indexing of an array.\n",
    "\n",
    "### Python indexing is 0 based! This means that the first entry in a row/column is indexed by 0! So, when we mention the (1,1) component of a 2-dimensional array, we must use [0,0] to access that specific component.\n",
    "***REMEMBER THIS!!!***\n",
    "There are also two common conventions for accessing components of arrays.\n",
    "\n",
    "The following diagram may prove useful for typical 2-D arrays.\n",
    "\n",
    "We say that the rows are aligned with ***axis 0*** and the columns are aligned with ***axis 1***.\n",
    "\n",
    "We explore these ideas and array slicing concepts below.\n",
    "\n",
    "![Visual of indexing array goes here](imgs/sample_array_basics.png \"Visual of indexing array\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "arr_2d = np.array( [ [1,2],[3,4],[5,6] ] )\n",
    "\n",
    "print()\n",
    "print(' arr_2d =\\n', arr_2d )\n",
    "\n",
    "print()\n",
    "print( '(1,1) component of arr_2d is given by arr_2d[0,0] =',  arr_2d[0,0] )\n",
    "\n",
    "print()\n",
    "print( '(1,2) component of arr_2d is given by arr_2d[0,1] =', arr_2d[0,1] )\n",
    "\n",
    "print()\n",
    "print( '(2,1) component of arr_2d is given by arr_2d[1,0] =', arr_2d[1,0] )\n",
    "\n",
    "print()\n",
    "print( '(3,2) component of arr_2d is given by arr_2d[2,1] =', arr_2d[2,1] )\n",
    "\n",
    "print()\n",
    "print( '(3,2) component of arr_2d is also given by arr_2d[-1,1] =', arr_2d[-1,1] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Try uncommenting the next line to see an error. Can you explain it?\n",
    "#print( arr_2d[2,2] ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "arr_3d = np.array( [ [ [1,2,3], [4,5,6] ],[ [7,8,9],[10,11,12] ] ] )\n",
    "\n",
    "print()\n",
    "print(' arr_3d =\\n\\n', arr_3d )\n",
    "\n",
    "print()\n",
    "print( '(1,1) component of arr_2d is given by \\n\\n arr_3d[0,0] =\\n\\n',  arr_3d[0,0] )\n",
    "\n",
    "print()\n",
    "print( '(1,1,2) component of arr_2d is given by \\n\\n arr_3d[0,0,1] =\\n\\n', arr_3d[0,0,1] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "arr_2d = np.array( [ [1,2],[3,4],[5,6] ] )\n",
    "\n",
    "print()\n",
    "print(' arr_2d =\\n\\n', arr_2d )\n",
    "\n",
    "# Using a colon : by itself when calling entries of an array will access all entries in the row/column\n",
    "# where the colon appears.\n",
    "print()\n",
    "print( 'first row of arr_2d is given by arr_2d[0,:] =\\n\\n', arr_2d[0,:] ) #preferred \n",
    "\n",
    "print()\n",
    "print( 'first row of arr_2d is also given by arr_2d[0] =\\n\\n', arr_2d[0] ) #not preferred\n",
    "\n",
    "print()\n",
    "print( 'first column of arr_2d is given by arr_2d[:,0] =\\n\\n', arr_2d[:,0] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Slicing\n",
    "\n",
    "The colon `:` operator is used to specify a range of values in a matrix.\n",
    "\n",
    "- The entry to the left of the `:` is included but the entry to the right of the `:` is not.\n",
    "\n",
    "\n",
    "- Think of `i:j` being interpreted as \"all entries starting at i up to, but ***not*** including, j\"\n",
    "\n",
    "\n",
    "- #### Also, think of `i:j` being interpreted as \"all entries starting at i up to, but ***not*** including, j\"\n",
    "\n",
    "\n",
    "- ### And, think of `i:j` being interpreted as \"all entries starting at i up to, but ***not*** including, j\"\n",
    "\n",
    "\n",
    "- ## Before we forget, you should also think of `i:j` being interpreted as \"all entries starting at i up to, but ***not*** including, j\"\n",
    "\n",
    "### Short quiz\n",
    "\n",
    "- How should you think of `i:j`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "A = np.reshape(range(1,13),(3,4)) # create a 3x4 array (i.e., a matrix) with the 1st 12 integers in it.\n",
    "\n",
    "print()\n",
    "print( 'The full matrix A is given by \\n\\n', A )\n",
    "\n",
    "print()\n",
    "print( 'To display just the 2nd and 3rd columns of A,\\n' +\n",
    "       'recall that we begin indexing from 0, so we use A[:,1:3] \\n\\n',\n",
    "        A[:,1:3])   #All rows, 2nd and 3rd (but not 4th) column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If you leave off a (later) index, it is implicity treated as if you had used a colon.\n",
    "\n",
    "If multiple rows and columns are being sliced, then this will ***generally*** give the same thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print()\n",
    "print( 'A[0:2] =\\n\\n', A[0:2] )\n",
    "\n",
    "print()\n",
    "print( 'A[0:2,:] =\\n\\n', A[0:2,:] )\n",
    "\n",
    "print()\n",
    "print( 'A[0:2]-A[0:2,:] =\\n\\n', A[0:2] - A[0:2,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "***However, if we are slicing just a single row or column, then there can be differences that lead to undesirable results.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print()\n",
    "print( 'A[:,1] =\\n\\n', A[:,1] )\n",
    "\n",
    "print()\n",
    "print( 'A[:,1].shape =', A[:,1].shape )\n",
    "\n",
    "print()\n",
    "print( 'A[:,1:2] =\\n\\n', A[:,1:2] )\n",
    "\n",
    "print()\n",
    "print( 'A[:,1:2].shape =', A[:,1:2].shape )\n",
    "\n",
    "print()\n",
    "print( 'A[:,1]-A[:,1:2] =\\n\\n', A[:,1] - A[:,1:2] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing from the end of an array\n",
    "\n",
    "The -n slice allows you to access entries from the last valid index.\n",
    "\n",
    "- Using a -1 in a slice will select the very last entry in the array.\n",
    "\n",
    "    - This implies that if you want to index from the 3rd entry in an array up to, but not including, the last entry in the array, then you would use `2:-1` in the slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print()\n",
    "print( A )\n",
    "\n",
    "print()\n",
    "print( A[-1,:] )   #the last row\n",
    "\n",
    "print()\n",
    "print( A[:,-2:] ) #the last two columns\n",
    "\n",
    "print()\n",
    "print( A[:,1:] ) #the second column through the last\n",
    "\n",
    "print()\n",
    "print( A[:,1:-1] ) #the second column up to, but not including, the last"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can give arrays as inputs to select some specific rows, columns, etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print()\n",
    "print( A )\n",
    "\n",
    "print()\n",
    "print( A[:,[1,3]] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elementwise vs standard operations in `numpy`\n",
    "\n",
    "`numpy` has functions for both elementwise multiplication of arrays (of the same size) and standard matrix-matrix/vector multiplication (where inner dimensions agree).\n",
    "\n",
    "- Use the `np.multiply` function for elementwise multiplication (can also just use `*`). Dimensions \n",
    "\n",
    "\n",
    "- Use the `np.dot` function for standard matrix-matrix, or matrix-vector multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array multiplication is **not** matrix multiplication.  It is an *elementwise* operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "A = np.reshape(range(1,13),(3,4)) # create a 3x4 array (i.e., a matrix) with the 1st 12 integers in it.\n",
    "B = np.reshape(range(1,13),(4,3)) # create a 4x3 array (i.e., a matrix) with the 1st 12 integers in it.\n",
    "\n",
    "print()\n",
    "print( A )\n",
    "\n",
    "print()\n",
    "print( B )\n",
    "\n",
    "print()\n",
    "print( np.multiply(A,A) )  #elementwise multiplication\n",
    "\n",
    "print()\n",
    "print( A*A )  #also elementwise multiplication\n",
    "\n",
    "print()\n",
    "print( np.dot( A, B ) ) #standard matrix-matrix multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More numpy functions and subpackages\n",
    "\n",
    "https://docs.scipy.org/doc/numpy/reference/ is a great reference. In particular, you should check out the available documentation on the `matlib`, `linalg`, and `random` subpackages. \n",
    "These are extremely useful subpackages that can do most of your everyday computations in undergraduate/beginning graduate mathematics.\n",
    "\n",
    "- The page on N-dimensional arrays (https://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html) is also very useful. Arrays inherent many methods (i.e., functions) from the `numpy` namespace that allow for quicker access to certain functionality (and shorter, more readable code).\n",
    "\n",
    "    - Many methods can be applied in one line of code where the order of operation is specified by the order in which the methods appear from left to right. ***We show some examples below.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print()\n",
    "print( A )\n",
    "\n",
    "print()\n",
    "print( np.mean(A) )\n",
    "\n",
    "print()\n",
    "print( A.mean() )\n",
    "\n",
    "print()\n",
    "print( np.transpose(A) )\n",
    "\n",
    "print()\n",
    "print( A.transpose() )\n",
    "\n",
    "print()\n",
    "print( A.max() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***We sometimes only want to apply a function across rows or columns.***\n",
    "It is common to arrange a set of samples as an array where each row defines a single sample, and the columns define the various quantitative entries associated with that sample (e.g., think of how a Jacobian matrix is ordered). We often then want to perform some sort of computation across the columns to determine some bulk characteristic for each sample.\n",
    "- If this is true, then remember that we index from 0 and the rows are the first index (axis=0) and the columns are the second index (axis=1) in the array when you specify which axis you want to perform computations *across*.\n",
    "\n",
    "![Visual of axis numbers for an array go here](imgs/sample_array.png \"The axis numbers for an array\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print()\n",
    "print( A )\n",
    "\n",
    "print()\n",
    "print( np.mean(A, axis=1) )\n",
    "\n",
    "print()\n",
    "print( A.mean(axis=1) )\n",
    "\n",
    "print()\n",
    "print( A.mean(axis=0) )\n",
    "\n",
    "print()\n",
    "print( A.transpose().mean(axis=1) ) #functions work from left to right\n",
    "\n",
    "print()\n",
    "print( A.transpose().mean(axis=0) ) #functions work from left to right"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting and `matplotlib`\n",
    "The mathematician Richard Hamming once said, “The purpose of computing is insight, not numbers,” and the best way to develop insight is often to visualize data. Visualization deserves an entire lecture (of course) of its own, but we can explore a few features of Python’s `matplotlib` library here. While there is no “official” plotting library, this package is the de facto standard. First, we will import the `pyplot` module from `matplotlib`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's `matplotlib` library emulates many features of Matlab plotting and uses the same layout for how it creates plots as illustrated below.\n",
    "\n",
    "![Illustration of plotting with matplotlib goes here](imgs/matplotlib_layout.png \"The items that make up a figure\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#The next line enables the display of graphical output within Jupyter Notebooks and is NOT needed outside of Notebooks\n",
    "%matplotlib inline \n",
    "\n",
    "#This next line IS needed even outside of Jupyter Notebook\n",
    "import matplotlib.pyplot as plt "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic plot command plots xdata versus ydata.  The default behavior is to connect data pairs via a straight solid line.\n",
    "\n",
    "The `np.linspace(a,b,n)` generates $n$ points in the closed interval $[a,b]$, including the endpoints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(-np.pi,np.pi,1000)\n",
    "\n",
    "y = x*np.sin(1.0/x)\n",
    "\n",
    "plt.title('$f(x)=x\\sin(x^{-1})$', fontsize=18)\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another handy way of generating a vector is using `numpy.arange(start,stop,increment)`\n",
    "This will fill up the half-open interval $[start,stop)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x_1 = np.arange(-np.pi,np.pi,1E-2)\n",
    "\n",
    "y_1 = x_1*np.sin(x_1)\n",
    "\n",
    "plt.plot(x_1,y_1,linestyle='--',c='r')  #dashed lines, red coloring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do a *scatter* plot of a noisy linear function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "xcor = np.random.rand(100)\n",
    "\n",
    "ycor = 5*xcor + np.random.rand(100)\n",
    "\n",
    "plt.scatter(xcor,ycor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subplots and 3d plots using `mpl_toolkits`\n",
    "Subplots are one way to arrange multiple plots into one axes. The subplot function takes the following arguments: ** `add_subplot(nrows, ncols, plot_number)`**\n",
    "\n",
    "You may find https://docs.scipy.org/doc/numpy/reference/generated/numpy.meshgrid.html to be a useful reference when determining how you want to index an array in 2- or 3-D. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(1, figsize=(10, 6))\n",
    "\n",
    "axes1 = fig.add_subplot(1, 3, 1) #the first plot in a 1x3 array\n",
    "axes2 = fig.add_subplot(1, 3, 2) #the second plot in a 1x3 array\n",
    "axes3 = fig.add_subplot(1, 3, 3) #the third plot in a 1x3 array\n",
    "\n",
    "axes1.set_ylabel('average')\n",
    "axes1.scatter(np.arange(A.shape[1]),np.mean(A, axis=0))\n",
    "axes1.set_xticks(np.arange(A.shape[1]))\n",
    "axes1.set_aspect(1)\n",
    "\n",
    "axes2.set_ylabel('max')\n",
    "axes2.plot(np.max(A, axis=0))\n",
    "axes2.set_xticks(np.arange(A.shape[1]))\n",
    "axes2.set_aspect(2)\n",
    "\n",
    "axes3.set_ylabel('min')\n",
    "axes3.plot(np.min(A, axis=0))\n",
    "axes3.set_aspect(3)\n",
    "\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#We will pretend that A is a function over the unit square in the xy-plane that we want to plot\n",
    "x = np.linspace(0,1,4) #we create a regular uniform grid in the x-direction\n",
    "y = np.linspace(0,1,3) #we create a regular uniform grid in the y-direction\n",
    "x, y = np.meshgrid(x,y,indexing='xy') #we then create a meshgrid in the xy-plane\n",
    "#print( x )\n",
    "#print( y )\n",
    "#print( A )\n",
    "\n",
    "from mpl_toolkits.mplot3d import axes3d #This enables 3d plotting\n",
    "\n",
    "fig = plt.figure(2, figsize=(10, 6))\n",
    "\n",
    "ax1 = fig.add_subplot(1, 3, 1, projection='3d')\n",
    "ax1.scatter(x, y, A) #we then plot A over this grid as a scatter plot\n",
    "ax1.set_xlabel('x')\n",
    "ax1.set_ylabel('y')\n",
    "ax1.set_zlabel('A')\n",
    "\n",
    "ax2 = fig.add_subplot(1, 3, 2, projection='3d')\n",
    "ax2.plot_wireframe(x, y, A) #we then plot A over this grid as a wireframe\n",
    "ax2.set_xlabel('x')\n",
    "ax2.set_ylabel('y')\n",
    "ax2.set_zlabel('A')\n",
    "\n",
    "from matplotlib import cm #Allow for more colormaps\n",
    "ax3 = fig.add_subplot(1, 3, 3, projection='3d')\n",
    "ax3.plot_surface(x, y, A, rstride=1, cstride=1, cmap=cm.coolwarm) #we then plot A over this grid as a surface\n",
    "ax3.set_xlabel('x')\n",
    "ax3.set_ylabel('y')\n",
    "ax3.set_zlabel('A')\n",
    "\n",
    "fig.tight_layout()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Numpy curve-fitting tools and matplotlib\n",
    "\n",
    "`numpy` has a `polyfit` function (https://docs.scipy.org/doc/numpy/reference/generated/numpy.polyfit.html) to perform least-squares fits of polynomials to data.\n",
    "\n",
    "In the code block below, `num_data` denotes the number of data points used to fit a polynomial curve to the noisy data defined by (`xdata`,`ydata`) where the `xdata` belongs to the interval [-4,4].\n",
    "Finish the code block so that\n",
    "\n",
    "   * A scatter plot of (`xdata`,`ydata`) is generated;\n",
    "   \n",
    "   * A third-order polynomial is fitted to the noisy data (read the `polyfit` documentation and look over the examples to see how to use `poly1d` to generate a polynomial function `p` from the output of the `polyfit` function);\n",
    "   \n",
    "   * Use `linspace` within `numpy` to create a regular uniform grid of [-4,4] called `xgrid` and plot (`xgrid`,`p(xgrid)`) on the same plot as the scatter of the noisy data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "num_data = 100\n",
    "\n",
    "xdata = np.random.rand(num_data)*8-4\n",
    "\n",
    "ydata = -xdata**3 + 2*xdata**2 + xdata + 2 + np.random.randn(num_data)*10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summary\n",
    "\n",
    "We have seen how to \n",
    "* Cast variables, print to screen using `print`, and make arrays/lists using built-in Python functions.\n",
    "* Import and use a library. \n",
    "* Use the numpy library to work with arrays in Python.\n",
    "* The expression array.shape gives the shape of an array.\n",
    "* Use array[x, y] to select a single element from an array and correctly select components of an array by understanding that array indices start at 0, not 1.\n",
    "* Use low:high to specify a slice that includes the indices from low to high-1.\n",
    "* Use `#` to add some kind of explanation in the form of comments to programs.\n",
    "* Use numpy.mean(array), numpy.max(array), and numpy.min(array) to calculate simple statistics.\n",
    "* Use numpy.mean(array, axis=0) or numpy.mean(array, axis=1) to calculate statistics across the specified axis.\n",
    "* Use the pyplot library from matplotlib for creating simple visualizations.\n",
    "* Use numpy.linspace, and numpy.meshgrid to create regular grids.\n",
    "\n",
    "# So what is next?\n",
    "\n",
    "Much of scientific programming involves applications of basic logic (e.g., using conditional statements to determine an action), repeating operations across arrays (e.g., using for-loops), and making user-defined functions to handle problem-specific issues. We will study these ideas in more depth in the next notebook of our short course.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}