01-numpy-tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CAFAXHWmt3rK"
   },
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dqtNBdkYt3rL"
   },
   "source": [
    "Python is a great general-purpose programming language on its own, but with the help of a few popular libraries (numpy, scipy, matplotlib) it becomes a powerful environment for scientific computing.\n",
    "\n",
    "We expect that many of you will have some experience with Python and numpy; for the rest of you, this section will serve as a quick crash course both on the Python programming language and on the use of Python for scientific computing.\n",
    "\n",
    "Some of you may have previous knowledge in Matlab, in which case we also recommend the numpy for Matlab users page (https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-users.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k9cGO68Gt3rP"
   },
   "source": [
    "In this tutorial, we will cover:\n",
    "\n",
    "* Basic Python: Basic data types (Containers, Lists, Dictionaries, Sets, Tuples), Functions, Classes\n",
    "* Numpy: Arrays, Array indexing, Datatypes, Array math, Broadcasting\n",
    "* Matplotlib: Plotting, Subplots, Images\n",
    "* IPython: Creating notebooks, Typical workflows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k9_4nxdXt3rQ"
   },
   "source": [
    "## Basics of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "J5fQCDgit3rR"
   },
   "source": [
    "Python is a high-level, dynamically typed multiparadigm programming language. Python code is often said to be almost like pseudocode, since it allows you to express very powerful ideas in very few lines of code while being very readable. As an example, here is an implementation of the classic quicksort algorithm in Python:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Kms0wPEUt3rY"
   },
   "source": [
    "### Python versions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lAxCz2fkt3rZ"
   },
   "source": [
    "There are currently two different supported versions of Python, 2.7 and 3.4. Somewhat confusingly, Python 3.0 introduced many backwards-incompatible changes to the language, so code written for 2.7 may not work under 3.4 and vice versa. For this class all code will use Python 2.7.\n",
    "\n",
    "You can check your Python version at the command line by running `python --version`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KHhcC5WDt3ra"
   },
   "source": [
    "### Basic data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "py1XL_Frt3ra"
   },
   "source": [
    "#### Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xgcjyHtSt3rb"
   },
   "source": [
    "Integers and floats work as you would expect from other languages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "lp3W4xPTt3rc",
    "outputId": "030dda0f-54f5-4435-b6b8-3153f50329be"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "HVX0y3a9t3rf",
    "outputId": "0810c938-7ab9-4ae5-9ca3-b25451732975"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "2\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print(x + 1)   # Addition;\n",
    "print(x - 1)   # Subtraction;\n",
    "print(x * 2)   # Multiplication;\n",
    "print(x ** 2)  # Exponentiation;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "RQlYZz1Xt3ri",
    "outputId": "06132ca5-42fd-429d-c87e-3d1407512ab6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "x += 1 # x = x+1\n",
    "print(x)  # Prints \"4\"\n",
    "x *= 2 # x = x*2\n",
    "print(x)  # Prints \"8\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "TubDYjk8t3rl",
    "outputId": "44810c49-9f8b-4987-b5d3-fcede3f0cca7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "2.5 3.5 5.0 6.25\n"
     ]
    }
   ],
   "source": [
    "y = 2.5\n",
    "print(type(y)) # Prints \"<type 'float'>\"\n",
    "print(y, y + 1, y * 2, y ** 2) # Prints \"2.5 3.5 5.0 6.25\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hS140ax1t3rr"
   },
   "source": [
    "Note that unlike many languages, Python does not have unary increment (x++) or decrement (x--) operators.\n",
    "\n",
    "Python also has built-in types for long integers and complex numbers; you can find all of the details in the [documentation](https://docs.python.org/2/library/stdtypes.html#numeric-types-int-float-long-complex)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lVxBQSS9t3rs"
   },
   "source": [
    "#### Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QMDwTYt6t3rt"
   },
   "source": [
    "Python implements all of the usual operators for Boolean logic, but uses English words rather than symbols (`&&`, `||`, etc.):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "HMwhH27wt3ru",
    "outputId": "b1b31601-7677-42f7-99ff-9503218faa59"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'> True False\n"
     ]
    }
   ],
   "source": [
    "t, f = True, False\n",
    "print(type(t),t,f) # Prints \"<type 'bool'>\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Y2XSV5lut3rx"
   },
   "source": [
    "Now we let's look at the operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "WcJz831Ht3ry",
    "outputId": "22f339cd-0ec6-4fd9-ef1e-11d4ede0f154"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(t and f) # Logical AND;\n",
    "print(t or f)  # Logical OR;\n",
    "print(not t)   # Logical NOT;\n",
    "print(t != f)  # Logical XOR;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_VqqbZBBt3r4"
   },
   "source": [
    "#### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "kXCfCpxNt3r4",
    "outputId": "eeb72479-38e3-411a-a513-b8ed405e4ecb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello 5\n"
     ]
    }
   ],
   "source": [
    "hello = 'hello'   # String literals can use single quotes\n",
    "world = \"world\"   # or double quotes; it does not matter.\n",
    "print(hello, len(hello))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "xjMwDiXMt3r9",
    "outputId": "e8eebd3b-1d73-4236-97a1-17bc7bc50cff"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "hw = hello + ' ' + world  # String concatenation\n",
    "print(hw)  # prints \"hello world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "5Kj-CkLKt3sD",
    "outputId": "d3d3a05f-aa22-48bd-f0c3-8847930a91d5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "HELLO\n",
      "  hello\n",
      " hello \n",
      "he(ell)(ell)o\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "s = \"hello\"\n",
    "print(s.capitalize())  # Capitalize a string; prints \"Hello\"\n",
    "print(s.upper())       # Convert a string to uppercase; prints \"HELLO \" hello \"\n",
    "print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another;\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "h-0eP08-t3sJ"
   },
   "source": [
    "You can find a list of all string methods in the [documentation](https://docs.python.org/2/library/stdtypes.html#string-methods)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "krLB0260t3sM"
   },
   "source": [
    "### Containers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "z1Dy5uQ1t3sN"
   },
   "source": [
    "Python includes several built-in container types: lists, dictionaries, sets, and tuples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "N9d_8JdJt3sO"
   },
   "source": [
    "#### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6uoWYT6vt3sO"
   },
   "source": [
    "A list is the Python equivalent of an array, but is resizeable and can contain elements of different types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "e1b8enC5t3sP",
    "outputId": "f7c58984-e0d1-465a-e894-1bda59070ace"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 2] 2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "xs = [3, 1, 2]   # Create a list\n",
    "print(xs, xs[2])\n",
    "print xs[-1]     # Negative indices count from the end of the list; prints \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "c-Spdm99t3sR",
    "outputId": "10181eb4-7e45-4217-9990-3a4069a58554"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1.1, 'foo']\n"
     ]
    }
   ],
   "source": [
    "xs[2] = 'foo'    # Lists can contain elements of different types\n",
    "xs[1] = 1.1\n",
    "print(xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "S01TOODnt3sT",
    "outputId": "5693af0f-7819-42d5-ab5c-2409b8e7a0f3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 'foo', 'bar']\n"
     ]
    }
   ],
   "source": [
    "xs.append('bar') # Add a new element to the end of the list\n",
    "print(xs)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "RQNeWMeXt3sW",
    "outputId": "85230422-0a18-4fff-f6fe-fcdd1c45d705"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bar [3, 1, 'foo']\n"
     ]
    }
   ],
   "source": [
    "x = xs.pop()     # Remove and return the last element of the list\n",
    "print(x, xs) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "v-xglXFtt3sb"
   },
   "source": [
    "As usual, you can find all the gory details about lists in the [documentation](https://docs.python.org/2/tutorial/datastructures.html#more-on-lists)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XtMxbgMxt3sc"
   },
   "source": [
    "#### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6dzt1bvPt3sc"
   },
   "source": [
    "In addition to accessing list elements one at a time, Python provides concise syntax to access sublists; this is known as slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "6fo3C_FKt3sd",
    "outputId": "b6e7af40-b3bb-4910-8539-cec3b7f13437"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "[2, 3]\n",
      "[2, 3, 4]\n",
      "[0, 1]\n",
      "[0, 1, 2, 3, 4]\n",
      "[0, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "nums = [0,1,2,3,4]    # range is a built-in function that creates a list of integers\n",
    "print(nums )        # Prints \"[0, 1, 2, 3, 4]\"\n",
    "print(nums[2:4])    # Get a slice from index 2 to 4 (exclusive); prints \"[2, 3]\"\n",
    "print(nums[2:])     # Get a slice from index 2 to the end; prints \"[2, 3, 4]\"\n",
    "print(nums[:2])     # Get a slice from the start to index 2 (exclusive); prints \"[0, 1]\"\n",
    "print(nums[:])      # Get a slice of the whole list; prints [\"0, 1, 2, 3, 4]\"\n",
    "print(nums[:-1])    # Slice indices can be negative; prints [\"0, 1, 2, 3]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7UBiL80Vt3sf"
   },
   "source": [
    "#### Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jGnkdusxt3sg"
   },
   "source": [
    "You can loop over the elements of a list like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "J7xUEmY7t3sg",
    "outputId": "4113d1fe-892e-452a-b555-ee0cc2c7bb08"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\n",
      "dog\n",
      "monkey\n"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for i in animals:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8DOhMqn0t3sk"
   },
   "source": [
    "If you want access to the index of each element within the body of a loop, use the built-in `enumerate` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "xTezhnA0t3sk",
    "outputId": "dd0255f2-1699-45f3-ec0e-284c53c3a30d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 cat\n",
      "1 dog\n",
      "2 monkey\n"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for i, j in enumerate(animals):\n",
    "    print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_tNePaVGt3tz"
   },
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1xKX8sfdt3t0"
   },
   "source": [
    "Python functions are defined using the `def` keyword. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "HaydwViXt3t1",
    "outputId": "f6ed0a64-7914-421b-ed4b-74cd0de5135c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "negative\n",
      "zero\n",
      "positive\n"
     ]
    }
   ],
   "source": [
    "def sign(x):\n",
    "    if x > 0:\n",
    "      return 'positive'\n",
    "    elif x < 0:\n",
    "      return 'negative'\n",
    "    else:\n",
    "       return 'zero'\n",
    "\n",
    "for x in [-1, 0, 1]:\n",
    "    print(sign(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "diiYY9wQt3uC"
   },
   "source": [
    "## Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uj_W7TSYt3uC"
   },
   "source": [
    "Numpy is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays. If you are already familiar with MATLAB, you might find this [tutorial](http://wiki.scipy.org/NumPy_for_Matlab_Users) useful to get started with Numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pMWdDslUt3uD"
   },
   "source": [
    "To use Numpy, we first need to import the `numpy` package:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "BTcP2sc8t3uE"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M7BaiSE1t3uI"
   },
   "source": [
    "### Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KEJqGvX1t3uJ"
   },
   "source": [
    "A numpy array is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nFStgMxzt3uJ"
   },
   "source": [
    "We can initialize numpy arrays from nested Python lists, and access elements using square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "fDXG5Gwxt3uK",
    "outputId": "becfc6d6-258c-4854-adc5-bc649b3d07f2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'> <class 'list'> (3,) 1 2 3\n",
      "[5 2 3]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "a = np.array([1, 2, 3])  # Create a rank 1 array\n",
    "print(type(a),type(x), a.shape, a[0], a[1], a[2])\n",
    "a[0] = 5                 # Change an element of the array\n",
    "print(a)                  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "lKz-QdWmt3uM",
    "outputId": "5f948c18-5ec1-4809-c280-14a848ef6886"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([[1,2,3],[4,5,6]])   # Create a rank 2 array\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "5_VyzPuWt3uP",
    "outputId": "2bf625c7-6d75-4f67-9736-fea78471cb33"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "1 2 4\n"
     ]
    }
   ],
   "source": [
    "print(b.shape)                 \n",
    "print(b[0, 0], b[0, 1], b[1, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "F6VwnG0et3uR"
   },
   "source": [
    "Numpy also provides many functions to create arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "WWkuvGhat3uR",
    "outputId": "f25bd74d-c0ef-4281-b21c-05dc5101d718"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  0.]\n",
      " [ 0.  0.  0.]] <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "a = np.zeros((2,3))  # Create an array of all zeros\n",
    "print(a,type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "HZ9F6ol-t3uT",
    "outputId": "2ebe8b52-1a9d-43b2-ce1f-0d1f91673d3f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "b = np.ones((1,2))   # Create an array of all ones\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "Pw_sQFCXt3uU",
    "outputId": "57d2ab3f-2beb-4b21-bdc6-d918ed6b0519"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 7]\n",
      " [7 7]]\n"
     ]
    }
   ],
   "source": [
    "c = np.full((2,2), 7) # Create a constant array\n",
    "print(c) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "PRZTNHDPt3uW",
    "outputId": "ce8a748a-4789-4e5f-fac7-e04696583893"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  0.  0.  0.  0.]\n",
      " [ 0.  1.  0.  0.  0.]\n",
      " [ 0.  0.  1.  0.  0.]\n",
      " [ 0.  0.  0.  1.  0.]\n",
      " [ 0.  0.  0.  0.  1.]]\n"
     ]
    }
   ],
   "source": [
    "d = np.eye(5)        # Create a 2x2 identity matrix\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "2FGvRD_Wt3uX",
    "outputId": "d29c7e30-561a-4da2-9ced-8455df3dcb0f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.72027499  0.82752901]\n",
      " [ 0.5726961   0.1042542 ]]\n"
     ]
    }
   ],
   "source": [
    "e = np.random.random((2,2)) # Create an array filled with random values\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4k2b9Dg4t3vO"
   },
   "source": [
    "### Datatypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6gK8SL56t3vO"
   },
   "source": [
    "Every numpy array is a grid of elements of the same type. Numpy provides a large set of numeric datatypes that you can use to construct arrays. Numpy tries to guess a datatype when you create an array, but functions that construct arrays usually also include an optional argument to explicitly specify the datatype. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "q7HOguKAt3vO",
    "outputId": "28a12534-b3b0-46b6-b44b-057b8a6ea4d5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64 float64 int64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2])  # Let numpy choose the datatype\n",
    "y = np.array([1.0, 2.0])  # Let numpy choose the datatype\n",
    "z = np.array([1, 2], dtype=np.int64)  # Force a particular datatype\n",
    "\n",
    "print(x.dtype, y.dtype, z.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cHBYxpqat3vS"
   },
   "source": [
    "You can read all about numpy datatypes in the [documentation](http://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SDcZNe2yt3vS"
   },
   "source": [
    "### Array math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YvqTL8kQt3vT"
   },
   "source": [
    "Basic mathematical functions operate elementwise on arrays, and are available both as operator overloads and as functions in the numpy module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "L8LmmFoqt3vT",
    "outputId": "21903ef4-0089-43b8-93bd-6489eb856933"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  6.   8.]\n",
      " [ 10.  12.]]\n",
      "[[  6.   8.]\n",
      " [ 10.  12.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "# Elementwise sum; both produce the array\n",
    "print(x + y)\n",
    "print(np.add(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "RBfOjtO8t3vV",
    "outputId": "a2137f4c-178b-4712-814d-d95119ea33a4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n"
     ]
    }
   ],
   "source": [
    "# Elementwise difference; both produce the array\n",
    "print(x - y)\n",
    "print(np.subtract(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "73iaFc-Zt3vX",
    "outputId": "013cbaa6-9a35-45f1-9e13-075875bfc01d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  5.  12.]\n",
      " [ 21.  32.]]\n",
      "[[  5.  12.]\n",
      " [ 21.  32.]]\n"
     ]
    }
   ],
   "source": [
    "# Elementwise product; both produce the array\n",
    "print(x * y)\n",
    "print(np.multiply(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "9K8C-S24t3vZ",
    "outputId": "7ae2e592-8948-489d-89ad-9bcc399ea3c8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.2         0.33333333]\n",
      " [ 0.42857143  0.5       ]]\n",
      "[[ 0.2         0.33333333]\n",
      " [ 0.42857143  0.5       ]]\n"
     ]
    }
   ],
   "source": [
    "# Elementwise division; both produce the array\n",
    "# [[ 0.2         0.33333333]\n",
    "#  [ 0.42857143  0.5       ]]\n",
    "print(x / y)\n",
    "print(np.divide(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "cl4tLqXat3vb",
    "outputId": "257bcf63-565a-472d-8a97-d34cce566936"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.          1.41421356]\n",
      " [ 1.73205081  2.        ]]\n"
     ]
    }
   ],
   "source": [
    "# Elementwise square root; produces the array\n",
    "# [[ 1.          1.41421356]\n",
    "#  [ 1.73205081  2.        ]]\n",
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "00sxrjSxt3vd"
   },
   "source": [
    "Note that unlike MATLAB, `*` is elementwise multiplication, not matrix multiplication. We instead use the dot function to compute inner products of vectors, to multiply a vector by a matrix, and to multiply matrices. dot is available both as a function in the numpy module and as an instance method of array objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "ZfBv3weDt3ve",
    "outputId": "58ed821b-1fe0-4302-e940-82431298fde4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "219\n",
      "219\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "y = np.array([[5,6],[7,8]])\n",
    "\n",
    "v = np.array([9,10])\n",
    "w = np.array([11, 12])\n",
    "\n",
    "# Inner product of vectors; both produce 219\n",
    "print(v.dot(w))\n",
    "print(np.dot(v, w))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "expSO1z5t3vg",
    "outputId": "c907e8b7-ae9b-4aeb-825f-5aa97afd1ddf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[29 67]\n",
      "[29 67]\n"
     ]
    }
   ],
   "source": [
    "# Matrix / vector product; both produce the rank 1 array [29 67]\n",
    "print(x.dot(v))\n",
    "print(np.dot(x, v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "122KzerIt3vh",
    "outputId": "1ba0af48-9076-4e03-da46-49594109228e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 22]\n",
      " [43 50]]\n",
      "[[19 22]\n",
      " [43 50]]\n"
     ]
    }
   ],
   "source": [
    "# Matrix / matrix product; both produce the rank 2 array\n",
    "# [[19 22]\n",
    "#  [43 50]]\n",
    "print(x.dot(y))\n",
    "print(np.dot(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hr6hFq0Nt3vj"
   },
   "source": [
    "Numpy provides many useful functions for performing computations on arrays; one of the most useful is `sum`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "BiQ6Jq1Yt3vj",
    "outputId": "d590309c-bb82-4ec0-901c-861629e8d235"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "[4 6]\n",
      "[3 7]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "\n",
    "print(np.sum(x)) # Compute sum of all elements; prints \"10\"\n",
    "print(np.sum(x, axis=0))  # Compute sum of each column; prints \"[4 6]\"\n",
    "print(np.sum(x, axis=1))  # Compute sum of each row; prints \"[3 7]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "irjCZv2st3vm"
   },
   "source": [
    "You can find the full list of mathematical functions provided by numpy in the [documentation](http://docs.scipy.org/doc/numpy/reference/routines.math.html).\n",
    "\n",
    "Apart from computing mathematical functions using arrays, we frequently need to reshape or otherwise manipulate data in arrays. The simplest example of this type of operation is transposing a matrix; to transpose a matrix, simply use the T attribute of an array object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "KrhGcVMjt3vn",
    "outputId": "5aca10d0-f166-4f3a-ea4f-3fe2840a6eea"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[1 3]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "print(x.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {}
     ]
    },
    "colab_type": "code",
    "id": "SO4rvE7rt3vt",
    "outputId": "a230f8a4-1bc1-4397-8585-8e43d9a34b29"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]]\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([[1,2,3]])\n",
    "print(v)\n",
    "print(v.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ibqgoOVZt3wf"
   },
   "source": [
    "## Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "egBIxXr1t3wf"
   },
   "source": [
    "Matplotlib is a plotting library. In this section give a brief introduction to the `matplotlib.pyplot` module, which provides a plotting system similar to that of MATLAB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "XzV9uGD5t3wg"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iTXPEK20t3wh"
   },
   "source": [
    "By running this special iPython command, we will be displaying plots inline:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "r1GbJiSQt3wi"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HEg40fNNt3wj"
   },
   "source": [
    "### Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DNsbDXmQt3wj"
   },
   "source": [
    "The most important function in `matplotlib` is plot, which allows you to plot 2D data. Here is a simple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {},
      {}
     ]
    },
    "colab_type": "code",
    "id": "6CIBZzAKt3wm",
    "outputId": "82c799d9-f002-423d-8e71-2e1bae2d03fa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5b0c1616a0>"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5b0c21b940>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_sin = np.sin(x)\n",
    "y_cos = np.cos(x)\n",
    "\n",
    "# Plot the points using matplotlib\n",
    "plt.plot(x, y_sin)\n",
    "plt.plot(x, y_cos)\n",
    "plt.xlabel('x axis label')\n",
    "plt.ylabel('y axis label')\n",
    "plt.title('Sine and Cosine')\n",
    "plt.legend(['Sine', 'Cosine'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "default_view": {},
   "name": "Python Numpy Tutorial.ipynb",
   "provenance": [],
   "version": "0.3.2",
   "views": {}
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}