Numpy introduction.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Short Numpy Tutorial\n",
      "\n",
      "This is a very short introduction to numpy, focused on the basic data structure, `ndarray`. Numpy is the most important scientific package in the Python ecosystem because it provides a common datastructure on which many other packages build on."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "![Python scientific ecosystem](http://luispedro.org/files/talks/2013/EuBIAS/figures/sciwheel.png)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To make this tutorial work on Python 2 & Python 3, let's import some future features into Python 2"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import print_function, division"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# np is the standard abbreviation for numpy in the code\n",
      "# Even the numpy docs use it\n",
      "import numpy as np"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## What is an ndarray?\n",
      "\n",
      "The `ndarray` is the biggest contribution of numpy. An ndarray is\n",
      "\n",
      "- a regular grid of N-dimensions,\n",
      "- homogeneous by default (all the elements have the same type),\n",
      "- contiguous block of memory with types corresponding to machine types (8-bit ints, 32 bit floats, 64-bit longs, ...).\n",
      "\n",
      "## Building an array (inline)\n",
      "\n",
      "We can build an array from Python lists:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr = np.array([\n",
      "    [1.2, 2.3, 4.0],\n",
      "    [1.2, 3.4, 5.2],\n",
      "    [0.0, 1.0, 1.3],\n",
      "    [0.0, 1.0, 2e-1]])\n",
      "print(arr)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Inspecting array properties"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(arr.dtype)\n",
      "print(arr.ndim)\n",
      "print(arr.shape)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This array is of `float64` (at least on my computer, probably on yours too), it has 2 dimensions and its shape is 4 rows and 3 columns.\n",
      "\n",
      "When constructing an array, we can explicitly specify the type:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "iarr = np.array([1,2,3], np.uint8)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Arithmetic operations on the array **respect the type and can including rounding and overflow**!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr *= 2.5\n",
      "iarr *= 2.5\n",
      "print(arr)\n",
      "print(iarr)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Boolean operations\n",
      "\n",
      "An important subset of operations with numpy arrays concerns using logical operators to build boolean arrays. For example:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "is_greater_one = (arr >= 1.)\n",
      "print(is_greater_one)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Slicing & Dicing\n",
      "\n",
      "We can use Python's `[]` operator to slice and dice the array:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(arr[0,0]) # First row, first column\n",
      "print(arr[1]) # The whole second row\n",
      "print(arr[:,2]) # The third column"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Slices are views\n",
      "\n",
      "Slices share memory with the original array!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"Before: {}\".format(arr[1,0]))\n",
      "view = arr[1]\n",
      "view[0] += 100\n",
      "print(\"After: {}\".format(arr[1,0]))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### Visual illustration of slicing"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.array([\n",
      "       [ 0,  1,  2,  3,  4,  5],\n",
      "       [10, 11, 12, 13, 14, 15],\n",
      "       [20, 21, 22, 23, 24, 25],\n",
      "       [30, 31, 32, 33, 34, 35],\n",
      "       [40, 41, 42, 43, 44, 45],\n",
      "       [50, 51, 52, 53, 54, 55]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "![slicing](https://scipy-lectures.github.io/_images/numpy_indexing.png)\n",
      "\n",
      "This image is taken from [scipy-lectures](https://scipy-lectures.github.io/intro/numpy/array_object.html), a more complete tutorial on numpy than what we have here."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Basic functions on arrays"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr.mean()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Also available: `max`, `min`, `sum`, `ptp` (point-to-point, i.e., difference between maximum and minimum values).\n",
      "\n",
      "These functions can also work *axis-wise*:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "arr.mean(axis=0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "An important trick is to combine logical operations with A"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "is_greater_one = (arr > 1)\n",
      "print(is_greater_one.mean())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Broadcasting\n",
      "\n",
      "You can often perform operations"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(arr)\n",
      "print(\"Now adding [1,1,0] to *every row*\")\n",
      "print()\n",
      "arr += np.array([1,1,0])\n",
      "print(arr)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The exact [rules of how broadcasting work](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) are a bit complex to explain, but it generally works as expected. For example, if your data is a set of measurements for a sample, and your columns are the different types of measurements, then, you can easily remove the mean like this:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(arr.mean(0))\n",
      "arr -= arr.mean(0)\n",
      "print(arr.mean(0))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Footnotes\n",
      "\n",
      "[homogeneous]: There is a loophole to get heterogeneous arrays, namely an array of `object`. Then, you can store any Python object. This comes at the cost of decreased computational efficiency (both in terms of processing time and memory usage)."
     ]
    }
   ],
   "metadata": {}
  }
 ]
}