numpy-notes.ipynb

{
 "metadata": {
  "name": "numpy-notes"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Introduction to Numpy\n",
      "Presenter notes for numpy--most of the text notes can be found in numpy.ipynb, but this contains just the code examples for review."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create 3 lists of a million ints\n",
      "A = range(1000000)\n",
      "B = range(1000000)\n",
      "C = range(1000000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Time doing the operation with a for loop\n",
      "import time\n",
      "\n",
      "start_time = time.time()\n",
      "\n",
      "Z = []\n",
      "for idx in xrange(len(A)):\n",
      "    Z.append(A[idx] + B[idx] * C[idx])\n",
      "    \n",
      "print 'Took', time.time() - start_time, 'seconds'\n",
      "    \n",
      "# print Z  # DON'T DO THIS!  It will print all 10000 array items"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create 3 Numpy arrays with a million ints\n",
      "\n",
      "import numpy as np\n",
      "\n",
      "A = np.arange(1000000)\n",
      "B = np.arange(1000000)\n",
      "C = np.arange(1000000)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Time the operation with Numpy\n",
      "start_time = time.time()\n",
      "\n",
      "Z = A + B * C\n",
      "\n",
      "print 'Took', time.time() - start_time, 'seconds'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Print the result\n",
      "Z = A + B * C\n",
      "print Z"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%pylab inline\n",
      "import numpy as np\n",
      "\n",
      "ax = subplot(111)\n",
      "x = np.arange(0.0, 5.0, 0.01)\n",
      "y = np.cos(x * np.pi)\n",
      "lines, = plot(x, y, lw=3)\n",
      "ylim(-1.5, 1.5)\n",
      "show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create an array from a list of ints and show the array\n",
      "import numpy\n",
      "\n",
      "vals = [1, 2, 3]\n",
      "arr = numpy.array(vals)\n",
      "arr"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Print the array--notice any difference?\n",
      "print arr"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create an array from a heterogeneous list\n",
      "arr = numpy.array([1, 2.3])\n",
      "arr"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create an array of floats from a list of ints\n",
      "numpy.array([1, 2, 3, 4], dtype=numpy.float32)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create arrays of ints, floats, and complex from lists of ints\n",
      "print numpy.array([1, 2, 3, 4], dtype=numpy.int)\n",
      "print numpy.array([1, 2, 3, 4], dtype=numpy.float)\n",
      "print numpy.array([1, 2, 3, 4], dtype=numpy.complex)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create an array of ints and show the dtype\n",
      "arr = numpy.array([1, 2, 3, 4], dtype=numpy.int32)\n",
      "print arr\n",
      "# Try reassigning the dtype to float\n",
      "arr.dtype = numpy.float32\n",
      "print arr\n",
      "# Restore the correct dtype and use .astype() instead\n",
      "arr.dtype = numpy.int32\n",
      "print arr.astype(numpy.float32)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create a 2x3 array of zeros\n",
      "z = numpy.zeros((2, 3))\n",
      "z"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create a 2x3 array of integer zeros\n",
      "z = numpy.zeros((2, 3), dtype=numpy.int32)\n",
      "z"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# The ones and identity functions work much the same way:\n",
      "numpy.ones((2, 3))\n",
      "numpy.identity(2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create a 2x2 empty array\n",
      "arr = numpy.empty((2, 2))\n",
      "arr"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Another frequently useful array creation function is arange:\n",
      "\n",
      "arr = np.arange(10, 20)\n",
      "print arr\n",
      "arr = np.arange(10, 20, 0.1)\n",
      "print arr"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# linspace can be used to create an n-sized array of evenly spaced samples in some range:\n",
      "\n",
      "arr = np.linspace(0, 100, 20)\n",
      "print arr\n",
      "\n",
      "axis([-1, 101, -1, 101])\n",
      "xlabel('foo')\n",
      "lines, = plot(arr, arr, 'ro')\n",
      "show()\n",
      "\n",
      "# logspace \n",
      "arr = np.logspace(0, 1, 20, base=10)\n",
      "print arr\n",
      "axis([0, 11, 0, 11])\n",
      "lines, = plot(arr, arr, 'go')\n",
      "show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create a 3x3 array\n",
      "\n",
      "import numpy as np\n",
      "\n",
      "example_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
      "example_array"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Variable assignment does not *copy* data in array; it just creates a new pointer to that array\n",
      "first = numpy.ones((2, 2))\n",
      "second = first\n",
      "print first"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# But index assignment updates elements in an array\n",
      "\n",
      "second[0, 0] = 9\n",
      "print first"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# If we really want a copy we can use the .copy() method\n",
      "first = numpy.ones((2, 2))\n",
      "print first\n",
      "second = first.copy()\n",
      "second[0, 0]\n",
      "print first"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Show the shape\n",
      "\n",
      "print first\n",
      "print first.shape"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Modify the shape with a valid shape\n",
      "\n",
      "first.shape = (4, 1)\n",
      "first"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Modify the shape with an invalid shape\n",
      "\n",
      "first.shape = (3, 2)\n",
      "first"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# You can use .shape to define new arrays with that shape\n",
      "blank = np.zeros(first.shape)\n",
      "blank"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Arrays also have .size and .nbytes attributes\n",
      "block = numpy.zeros((4, 7, 3))\n",
      "print 'size:', block.size\n",
      "print 'nbytes:', block.nbytes"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# .transpose() creates a *view* of the same data but transposed\n",
      "\n",
      "arr = numpy.array([[1, 2, 3],\n",
      "                   [4, 5, 6]])\n",
      "\n",
      "print arr.transpose()\n",
      "print\n",
      "print 'The original array is unchanged:'\n",
      "print arr"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# We can also use arr.T\n",
      "print arr.T"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# .ravel() creates a 1-dimensional view of the original data\n",
      "print arr.ravel()\n",
      "print \n",
      "print 'The original array is still unchanged:'\n",
      "print arr"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Remember, the result of .ravel() is just a view; updating the array returned by\n",
      "# .ravel() updates the original array data too\n",
      "arr.ravel()[3] = 9\n",
      "print arr"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Resize a larger array to a smaller array\n",
      "\n",
      "block = numpy.arange(9)\n",
      "print block\n",
      "print\n",
      "\n",
      "block.resize(2, 2)\n",
      "print block"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Resize a smaller array to a larger array\n",
      "small = numpy.ones((2, 2))\n",
      "print small\n",
      "print\n",
      "\n",
      "large = small.copy()\n",
      "large.resize(3, 3)\n",
      "print large"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Fill a corner of an array from a smaller array\n",
      "large = numpy.zeros((3, 3))\n",
      "large[:2, :2] = small\n",
      "print large"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Assign zero to a slice of the first row\n",
      "block = numpy.array([[10, 20, 30, 40],\n",
      "                     [110, 120, 130, 140],\n",
      "                     [210, 220, 230, 240]])\n",
      "block[0, 1:3] = 0\n",
      "print block"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create a 2D array\n",
      "original = numpy.ones((3, 2))\n",
      "original"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Slice a corner of of the array\n",
      "slc = original[0:2, 0:2]\n",
      "slc"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Set the values of the slice to zero--the original has changed\n",
      "slc[:, :] = 0\n",
      "original"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Assign a slice of a vector to another slice of the same vector\n",
      "vector = numpy.array([10, 20, 30, 40])\n",
      "vector[0:3] = vector[1:4]\n",
      "vector"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create the vector [0, 10, 20, 30] using arange() and *\n",
      "vector = numpy.arange(4) * 10\n",
      "vector"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Index with a list of indices\n",
      "subscript = [3, 1, 2]\n",
      "vector[subscript]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# It should be emphasized that arbitrary subscripting returns a *copy* of the original array:\n",
      "sub = vector[subscript]\n",
      "sub[:] = 0\n",
      "vector"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# It is however possible to assignment using an arbitrary subscript\n",
      "subscript = [0, 3]\n",
      "vector[subscript] = 42\n",
      "vector"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Mask an array [0 1 2 3] with the mask [T F T F]\n",
      "a = numpy.array([0, 1, 2, 3])\n",
      "mask = numpy.array([True, False, True, False])\n",
      "a[mask]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Assign [101 102 103 104] using the mask\n",
      "a[mask] = numpy.array([101, 102, 103, 104])\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Note: For the above to work the mask must be a Numpy array.\n",
      "# Using a normal Python list of bools returns a different result (Why?)\n",
      "a[[True, False, True, False]]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Give the items <= 20 of [0 10 20 30]\n",
      "vector = numpy.array([0, 10, 20, 30])\n",
      "vector <= 20"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Gives the items <= 20 and > 0\n",
      "(vector <= 20) and (vector > 0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Do the same expression with logical_and\n",
      "numpy.logical_and(vector <= 20, vector > 0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Do the same expression with &\n",
      "(vector <= 20) & (vector > 0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Since comparison operators return an array of bools, a comparison expression\n",
      "# can also be used to index an array\n",
      "\n",
      "array1 = np.array([1, 1, 1, 2, 2, 2, 1])\n",
      "array2 = np.array([1, 2, 3, 4, 5, 6, 7])\n",
      "array2[array1 == 1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "array1 = np.array([1, 1, 1, 2, 2, 2, 1])\n",
      "array2 = np.array([1, 2, 3, 4, 5, 6, 7])\n",
      "\n",
      "array1 * 2 + 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Multiply array1 and array2\n",
      "array1 * array2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Create a 2x2 array and multiply it with itself\n",
      "arr = numpy.array([[1, 2], [3, 4]])\n",
      "arr * arr"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Now add it with itself\n",
      "arr + arr"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Add 1 to all elements--note that this does not *modify* arr\n",
      "arr + 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Sum the array\n",
      "numpy.sum(arr)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Sum along the row-axis\n",
      "numpy.sum(arr, axis=0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Sum along the column-axis\n",
      "numpy.sum(arr, axis=1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Make a 3x3 and a 1x3 matrix and mupltiply the former by the transpose of the latter\n",
      "matrix1 = np.matrix([[1, 2, 3], [4, 5, 6]])\n",
      "matrix2 = np.matrix([1, 2, 3])\n",
      "matrix1 * matrix2.transpose()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "matrix1 * matrix1.transpose()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "!cat data/examp_data.txt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Use genfromtxt() to create an array from the file\n",
      "data = np.genfromtxt('./data/examp_data.txt', delimiter=',', skip_header=1)\n",
      "data"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "# Use savetxt() to dump the output to a new file with a different delimiter\n",
      "np.savetxt('./data/examp_output.txt', data, delimiter=', ')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "!cat data/examp_output.txt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "!cat data/examp_data_species_mass.txt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Use genfromtxt to create a table from the data including the column names\n",
      "data = np.genfromtxt('./data/examp_data_species_mass.txt', dtype=None, names=True, delimiter=',')\n",
      "data"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "def export_to_csv(data, filename):\n",
      "    outputfile = open(filename, 'wb')\n",
      "    datawriter = csv.writer(outputfile)\n",
      "    datawriter.writerows(data)\n",
      "    outputfile.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### Selecting columns by name"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "data = np.genfromtxt('./data/examp_data_species_mass.txt', dtype=None, names=True, delimiter=',')\n",
      "print data\n",
      "data['species']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### Subset columns based on the values in other columns"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Select the masses from rows in which the species is 'DM'\n",
      "data['mass'][data['species'] == 'DM']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Same as above but only where site==1\n",
      "data['mass'][(data['species'] == 'DM') & (data['site'] == 1)]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Random number generation\n",
      "#### Random uniform (0 to 1)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.random.rand(3, 5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### Random normal (mean=0, stdev=1)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.random.randn(4, 2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### Random integers"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "min = 10\n",
      "max = 20\n",
      "np.random.randint(min, max, [10, 2])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}