Python/Python (3).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: numpy, and matplotlib\n",
    "\n",
    "This is a tutorial on scientific Python for the [KIPAC computing boot camp](http://kipac.github.io/BootCamp).\n",
    "\n",
    "Authors: [Yao-Yuan Mao](http://yymao.github.io), [Joe DeRose](https://github.com/j-dr), [Mike Baumer](https://mbaumer.github.io)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function, division\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from IPython.display import display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Trouble with lists\n",
    "Python lists are great, but have significant limitations in the context of scientific computing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [23,34,23,5]\n",
    "a[1] #useful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.append(3)\n",
    "a #useful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2*a # not typically useful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a**2 #argh!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a*a #argh!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries aren't much better for math:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = {'entry1' : 34, 'entry2' : 45, 'entry3' : 23}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#also, lists are slow at mathematical calculations\n",
    "def list_square(a):\n",
    "    squared = []\n",
    "    for entry in a:\n",
    "        squared.append(entry**2)\n",
    "    return squared\n",
    "\n",
    "def array_square(a):\n",
    "    return np.power(a,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "big_list = 1000*[3]\n",
    "big_array = np.array(big_list)\n",
    "%timeit list_square(big_list)\n",
    "%timeit array_square(big_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy and matplotlib are the workhorse packages of the scientist using python. Efficient use of numpy is the only way to perform most operations in a tractable amount of time in python. Once you've performed those operations, matplotlib is the go to package for visualization.\n",
    "\n",
    "## Outline\n",
    "* **Numpy**\n",
    "    * Creating arrays  \n",
    "    * Manipulating arrays  \n",
    "    * Under the hood\n",
    "    * Common array operations\n",
    "    * Useful functions\n",
    "* **Matplotlib**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy\n",
    "Why use numpy instead of regular old python?\n",
    "\n",
    "**python** has built-in:   \n",
    "containers: lists (costless insertion and append), dictionaries (fast lookup),...  \n",
    "high-level number objects: integers, floating point\n",
    "\n",
    "\n",
    "**numpy** is:   \n",
    "an extension package to Python for multidimensional arrays   \n",
    "closer to hardware (efficiency)   \n",
    "designed for scientific computation (convenience)   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating arrays\n",
    "The fundamental object in numpy is the ndarray. There are many different ways to create an array, as outlined below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#an array of all zeros (pass in the shape of the array you want)\n",
    "shape = (10,10)\n",
    "z = np.ndarray(shape)\n",
    "print('The shape of this array is {0}'.format(z.shape))\n",
    "display(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#an array of zeros\n",
    "z = np.zeros(shape)\n",
    "display(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#A range of integers\n",
    "a = np.arange(100)\n",
    "display(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#An array with numbers at linearly spaced intervals\n",
    "l = np.linspace(0,5,100)\n",
    "display(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#An array with numbers at log spaced intervals\n",
    "l = np.logspace(1,5,100)\n",
    "display(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1-d array creation from a list\n",
    "l = range(100)\n",
    "print(type(l))\n",
    "print(l)\n",
    "la = np.array(l)\n",
    "print(type(la))\n",
    "display(la)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2-d array creation from a list\n",
    "l = [[0,1,2], [3,4,5]]\n",
    "la = np.array(l)\n",
    "display(la)\n",
    "print(la.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#3-d array\n",
    "c = np.array([[[1], [2]], [[3], [4]]])\n",
    "display(c)\n",
    "print(c.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of the elements in an ndarray are specified in the array's dtype attribute. Numpy arrays can contain more than one type of data, but the types must be specified via the dtype!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#these are different arrays!\n",
    "a = np.array([1, 2, 3])\n",
    "print('This array has type {0}'.format(a.dtype))\n",
    "\n",
    "\n",
    "b = np.array([1., 2., 3.])\n",
    "print('This array has type {0}'.format(b.dtype))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Type can be specified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([0.,1.,2.], dtype=int)\n",
    "print(a.dtype)\n",
    "\n",
    "#default dtype is float\n",
    "a = np.zeros(2)\n",
    "print(a.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can have more than one type in an array, but it must be done in a particular fasion, and the type must have a predictable size in memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#can't do this\n",
    "z = np.ones(3)\n",
    "print(z.dtype)\n",
    "z[0] = 1.\n",
    "z[1] = 1\n",
    "z[2] = 'h'\n",
    "display(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#but can do it using more complex dtypes\n",
    "dt = np.dtype([('c1', np.float), ('c2', np.int), ('c3', 'S140')])\n",
    "z = np.ones(3, dtype=dt)\n",
    "print(z.dtype)\n",
    "print(z.shape)\n",
    "display(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This type of array is called a record array. A few things to note:\n",
    "\n",
    "* It is still considered a 1 dimensional array, even though it has more than 1 column.\n",
    "* Accessing elements of a record array is a bit different.\n",
    "* We are required to name the different fields and define their datatypes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#check the names of the fields\n",
    "z.dtype.names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#accessing all rows of a particular field yields a normal array\n",
    "print(z['c1'])\n",
    "print(z['c1'].dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#accessing a row\n",
    "print(z[0])\n",
    "print(z[0].dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The size of the variable being assigned must be pre determined. We can't put strings longer than the length that was specified in the dtype!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z['c3'][0] = 150*'x'\n",
    "len(z['c3'][0]) #whoops!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "Create an array that can store strings of length at most 200 as well as booleans. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing and slicing\n",
    "Numpy arrays support all the same indexing and slicing operations that standard python lists do. Numpy arrays are C ordered (the rows are indexed by the first index, columns by the second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(100)\n",
    "#numpy arrays are zero indexed\n",
    "a[0], a[4], a[10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#slicing\n",
    "a[0:10:2] #syntax is same as for lists start:stop:step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#indices of multi dimensional arrays are tuples of integers\n",
    "x = a.reshape(10,10)\n",
    "display(x)\n",
    "print(x[1,0])\n",
    "print(x[0,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "Create a 8x8 matrix and fill it with a checkerboard pattern"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fancy Indexing\n",
    "In addition to the standard list indexing and slicing operations, we can also use arrays and lists of integers or bools to index numpy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can also use lists or other numpy arrays to index\n",
    "x = np.arange(200)\n",
    "x[[10,20,45]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#when indexing with arrays of ints, the output takes the shape of the index\n",
    "a = np.arange(10)\n",
    "idx = np.array([[3, 4], [9, 7]])\n",
    "print(a[idx])\n",
    "print(a[idx].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#we can also use boolean masks to index arrays\n",
    "np.random.seed(3)\n",
    "a = np.random.randint(0, 20, 15)\n",
    "print(a)\n",
    "print(a % 3 == 0)\n",
    "mask = (a % 3 == 0)\n",
    "extract_from_a = a[mask] # or,  a[a%3==0]\n",
    "extract_from_a "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But indexing like this is much slower. We will see why in a moment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit x[range(10000)[::100]]\n",
    "%timeit x[::100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "Create a 10 × 5 array with random numbers between 0 and 1. Construct the (one-dimensional) array returning the values of the array closest to 0.66 for each row using fancy indexing. Do the same for the columns.\n",
    "\n",
    "**Hint**: You'll need to use the functions np.argmin and np.abs. Look up how they work!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Under the hood\n",
    "\n",
    "In order to understand why certain operations are more efficient than others in numpy, we need to understand views and copying of arrays. Below we perform two different operations that do the same thing, one much slower than the other. \n",
    "\n",
    "It is also very important to know what operations produce views in order to avoid hard to find bugs!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(filename='ndarray_layout.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x.strides)\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.zeros(100, dtype=np.dtype([('a', np.float), ('b', 'S100')]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x.strides)\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depending on how we index an array, either a new array will be created by copying the old array, or we will get a 'view'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fa = x[range(10000)[::100]]\n",
    "sa = x[::100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fa.base is x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#If an array does not own it's own data, we say it is a view of an array\n",
    "sa.base is x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for instance, transposes of arrays are actually views\n",
    "sa.T.flags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#if an array owns its own data, its base will be None\n",
    "print(fa.base)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(100).reshape(10,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "Does the following two operations result in a views or a copies?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "at = a.T\n",
    "af = a.T.ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### broadcasting\n",
    "Broadcasting is a way of performing operations on numpy arrays of different shapes. \n",
    "\n",
    "When operating on two arrays, NumPy compares their shapes element-wise. It starts with the trailing dimensions, and works its way forward. Two dimensions are compatible when\n",
    "\n",
    "* they are equal, or\n",
    "* one of them is 1\n",
    "\n",
    "If these conditions are not met, an ```ValueError```  is thrown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(40).reshape(5, 8)\n",
    "display(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = a + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a += 1\n",
    "display(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.arange(-1, -9, -1)\n",
    "display(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = np.array([10,20,30,40,50])\n",
    "display(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a + c  # this would raise an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a += c[:,np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.median(a, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.std(a, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first rule of numpy: **AVOID LARGE FOR LOOPS** (instead, use [ufuncs](http://docs.scipy.org/doc/numpy/reference/ufuncs.html))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(1000)\n",
    "%timeit a**2\n",
    "%timeit [i**2 for i in a] #these yield identical answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### searching and sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[4, 3, 5], [1, 2, 1]]) \n",
    "display(a)\n",
    "b = np.sort(a, axis=1) #sorts each column independently; to sort row entries together use pandas\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#but can do it using more complex dtypes\n",
    "dt = np.dtype([('c1', np.float), ('c2', np.float), ('c3', np.float)])\n",
    "z = np.random.rand(3,3)\n",
    "z.dtype = dt\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices = np.argsort(z,axis=0,order='c1')\n",
    "z[indices,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices = np.argsort(z,axis=0,order='c2')\n",
    "z[indices,:] # again, pandas is easier here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#once sorted, can use fast search algorithms\n",
    "x = np.random.randint(0, high=100, size=1000)\n",
    "x.sort()\n",
    "i = x.searchsorted(27)\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5\n",
    "Write a function which sorts a 2d array by it's nth column."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### useful functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(15).reshape(5,3)\n",
    "b = np.arange(12).reshape(3,4)\n",
    "\n",
    "display(a)\n",
    "display(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.dot(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(30).reshape(5,3,2)\n",
    "b = np.arange(60).reshape(3,4,5)\n",
    "\n",
    "display(a)\n",
    "display(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.einsum('ijk,jli', a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can find most mathematical function. \n",
    "# For special functions, find them in `scipy.special`\n",
    "\n",
    "x = np.linspace(0, np.pi*2, 101)\n",
    "plt.plot(x, np.cos(x))\n",
    "plt.plot(x, np.sin(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dealing with bool array\n",
    "\n",
    "a = np.random.randint(2, size=20).astype(bool)\n",
    "display(a)\n",
    "display(np.count_nonzero(a))\n",
    "display(np.where(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# argsort\n",
    "\n",
    "a = np.random.rand(10)\n",
    "\n",
    "display(a)\n",
    "display(a.argsort())\n",
    "\n",
    "display(a[a.argsort()])\n",
    "\n",
    "# note: to sort \"in place\", just do a.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# argmax and unravel_index\n",
    "\n",
    "a = np.random.rand(100)\n",
    "display(a.argmax())\n",
    "\n",
    "a = np.random.rand(100, 100)\n",
    "display(a.argmax())\n",
    "display(np.unravel_index(a.argmax(), a.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# different ways to do histogram\n",
    "\n",
    "a = np.random.rand(500)\n",
    "bins = np.linspace(0, 1, 21)\n",
    "\n",
    "display(np.bincount(np.searchsorted(bins, a)))\n",
    "\n",
    "display(np.histogram(a, bins))\n",
    "\n",
    "display(np.searchsorted(a, bins, sorter=a.argsort()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task \n",
    "\n",
    "Given an 2-D int array, fill the 0th row and 0th column with 1, and the rest by the following rule:\n",
    "\n",
    "    a[i,j] = a[i-1,j] + a[i,j-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run this cell to see hints\n",
    "\n",
    "hint = 'Pqv|{B\\x125(_wzs(wv(wvm(zw\\x7f(i|(i(|qum6(\\x125(aw}/tt(vmml(i(v}ux\\x81(n}vk|qwv6(Vw|({}zm(\\x7fpqkp(wvmG(\\\\z\\x81(z}v(hvx6twwsnwz0/k}u}ti|q~m/1h6'\n",
    "print((np.array(map(ord, hint), np.int8)-8).tostring())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.lookfor('cumulative')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## matplotlib\n",
    "\n",
    "The easiest way to learn is to look at the [gallery](http://matplotlib.org/gallery.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(ncols=2, nrows=2)\n",
    "ax1, ax2, ax3, ax4 = axes.flat\n",
    "\n",
    "# scatter plot (Note: `plt.scatter` doesn't use default colors)\n",
    "x, y = np.random.normal(size=(2, 200))\n",
    "ax1.plot(x, y, 'o')\n",
    "\n",
    "# sinusoidal lines with colors from default color cycle\n",
    "L = 2*np.pi\n",
    "x = np.linspace(0, L)\n",
    "ncolors = len(plt.rcParams['axes.color_cycle'])\n",
    "shift = np.linspace(0, L, ncolors, endpoint=False)\n",
    "for s in shift:\n",
    "    ax2.plot(x, np.sin(x + s), '-')\n",
    "ax2.margins(0)\n",
    "\n",
    "# bar graphs\n",
    "x = np.arange(5)\n",
    "y1, y2 = np.random.randint(1, 25, size=(2, 5))\n",
    "width = 0.25\n",
    "ax3.bar(x, y1, width)\n",
    "ax3.bar(x+width, y2, width, color=plt.rcParams['axes.color_cycle'][2])\n",
    "ax3.set_xticks(x+width)\n",
    "ax3.set_xticklabels(['a', 'b', 'c', 'd', 'e'])\n",
    "\n",
    "# circles with colors from default color cycle\n",
    "for color in plt.rcParams['axes.color_cycle']:\n",
    "    ax4.add_patch(plt.Circle(np.random.randn(2), radius=0.3, color=color))\n",
    "ax4.axis('equal')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise Solutions\n",
    "### Exercise 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.zeros(100, dtype=np.dtype([('stringcol', 'S200'), ('boolcol', bool)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.zeros((8,8))\n",
    "x[1::2, ::2] = 1\n",
    "x[::2, 1::2] = 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = np.random.rand(10,5)\n",
    "x = z[np.arange(10),np.argmin(np.abs(z-0.66), axis=1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. View\n",
    "2. Copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#slow\n",
    "def maxn(x, n):\n",
    "    return x[np.argsort(x)[-n:]]\n",
    "\n",
    "#fast\n",
    "def maxn(x, n):\n",
    "    return x[np.argpartition(-1*x,n)[:n]]\n",
    "\n",
    "maxn(np.random.randint(5,1000, 1000), 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.zeros((6, 6), int)\n",
    "\n",
    "for i, row in enumerate(a):\n",
    "    if i ==0 :\n",
    "        row[:] = 1\n",
    "    else:\n",
    "        row[:] = np.cumsum(a[i-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}