numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![data-x](http://oi64.tinypic.com/o858n4.jpg)\n",
    "\n",
    "---\n",
    "# NumPy Data X \n",
    "\n",
    "**Author:** Alexander Fred-Ojala & Ikhlaq Sidhu\n",
    "\n",
    "**License Agreement:** Feel free to do whatever you want with this code\n",
    "\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is NumPy:  \n",
    "\n",
    "NumPy stands for Numerical Python and it is the fundamental package for scientific computing with Python. It is a package that lets you efficiently store and manipulate numerical arrays. It contains among other things:\n",
    "\n",
    "* a powerful N-dimensional array object\n",
    "* sophisticated (broadcasting) functions\n",
    "* tools for integrating C/C++ and Fortran code\n",
    "* useful linear algebra, Fourier transform, and random number capabilities\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy contains an array object that is \"fast\"\n",
    "\n",
    "\n",
    "<img src=\"https://github.com/ikhlaqsidhu/data-x/raw/master/imgsource/threefundamental.png\">\n",
    "\n",
    "\n",
    "It stores:\n",
    "* location of a memory block (allocated all at one time)\n",
    "* a shape (3 x 3 or 1 x 9, etc)\n",
    "* data type / size of each element\n",
    "\n",
    "The core feauture that NumPy supports is its multi-dimensional arrays. In NumPy, dimensions are called axes and the number of axes is called a rank."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# written for Python 3.6\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.12.1'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.__version__ # made for v. 1.13.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Creating a NumPy Array: - \n",
    "### 1. Simplest possible: We use a list as an argument input in making a NumPy Array\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create array from Python list\n",
    "list1 = [1, 2, 3, 4]\n",
    "data = np.array(list1)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find out object type\n",
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# See data type that is stored in the array\n",
    "data.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# The data types are specified for the full array, if we store\n",
    "# a float in an int array, the float will be up-casted to an int\n",
    "data[0] = 3.14159\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.2  2.   3.   4. ]\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "# NumPy converts to most logical data type\n",
    "list2 = [1.2, 2, 3, 4]\n",
    "data2 = np.array(list2)\n",
    "print(data2)\n",
    "print(data2.dtype) # all values will be converted to floats if we have one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1' '2' '3']\n",
      "<U1\n"
     ]
    }
   ],
   "source": [
    "# We can manually specify the datatype\n",
    "list3 = [1, 2, 3]\n",
    "data3 = np.array(list3, dtype=str) #manually specify data type\n",
    "print(data3)\n",
    "print(data3.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([     0,      1,      2, ...,  99998,  99999, 100000])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lists can also be much longer\n",
    "list4 = range(100001)\n",
    "data = np.array(list4)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100001"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data) # to see the length of the full array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# data = np.array(1,2,3,4, 5,6,7,8,9) # wrong\n",
    "data = np.array([1,2,3,4,5,6,7,8,9]) # right\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# see documentation, the first keyword is the object to be passed in\n",
    "np.array?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More info on data types can be found here:\n",
    "https://docs.scipy.org/doc/numpy-1.13.0/user/basics.types.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accessing elements: Slicing and indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n",
      "[1 2 3]\n",
      "[4 5 6 7 8 9]\n",
      "[9 7 5 3 1]\n"
     ]
    }
   ],
   "source": [
    "# Similar to indexing and slicing Python lists:\n",
    "print(data[:])\n",
    "print (data[0:3])\n",
    "print (data[3:])\n",
    "print (data[::-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]\n",
      "\n",
      "[ 5  7  9 11 13]\n",
      "[15 14 13 12 11 10  9  8  7  6]\n"
     ]
    }
   ],
   "source": [
    "# more slicing\n",
    "x = np.array(range(25))\n",
    "print ('x:',x)\n",
    "print()\n",
    "print (x[5:15:2])\n",
    "print (x[15:5:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays are like lists, but different\n",
    "NumPy utilizes efficient pointers to a location in memory and it will store the full array in memory. Lists on the other hand are pointers to many different objects in memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing returns a view in Numpy, \n",
    "# and not a copy as is the case with Python lists\n",
    "\n",
    "\n",
    "data = np.array(range(10))\n",
    "view = data[0:3]\n",
    "view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = list(range(10))\n",
    "copy = l[0:3]\n",
    "copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[99, 1, 2]\n",
      "[99  1  2]\n"
     ]
    }
   ],
   "source": [
    "copy[0] = 99\n",
    "view[0] = 99\n",
    "print(copy)\n",
    "print(view)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python list: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "NumPy array: [99  1  2  3  4  5  6  7  8  9]\n"
     ]
    }
   ],
   "source": [
    "print('Python list:',l) # has not changed\n",
    "print('NumPy array:',data) # has changed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array copy [99  1  2]\n",
      "New array copy [555   1   2]\n",
      "Original array [99  1  2  3  4  5  6  7  8  9]\n"
     ]
    }
   ],
   "source": [
    "# Creating copies of the array instead of views\n",
    "arr_copy = data[:3].copy() \n",
    "print('Array copy',arr_copy)\n",
    "arr_copy[0] = 555\n",
    "print('New array copy',arr_copy)\n",
    "print('Original array',data) # now it is not a view any more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]\n",
      "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same thing with assignment, its not a copy, its the same data\n",
    "x = np.array(range(25))\n",
    "print (x)\n",
    "y = x\n",
    "y[:] = 0\n",
    "print (x)\n",
    "x is y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arrays are a lot faster than lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "# Arrays are faster and more efficient than lists\n",
    "\n",
    "x = list(range(100000))\n",
    "y = [i**2 for i in x]\n",
    "print (y[0:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time for Python lists:\n",
      "20.2 ms ± 636 µs per loop (mean ± std. dev. of 7 runs, 20 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Time the operation with some IPython magic command\n",
    "print('Time for Python lists:')\n",
    "list_time = %timeit -o -n 20 [i**2 for i in x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  4  9 16]\n"
     ]
    }
   ],
   "source": [
    "z = np.array(x)\n",
    "w = z**2\n",
    "print(w[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time for NumPy arrays:\n",
      "70.8 µs ± 14.7 µs per loop (mean ± std. dev. of 7 runs, 20 loops each)\n"
     ]
    }
   ],
   "source": [
    "print('Time for NumPy arrays:')\n",
    "np_time = %timeit -o -n 20 z**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NumPy is 208.0 times faster than lists at squaring 100 000 elements.\n"
     ]
    }
   ],
   "source": [
    "print('NumPy is ' + str(list_time.all_runs[0]//np_time.all_runs[0]) + ' times faster than lists at squaring 100 000 elements.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Universal functions\n",
    "A function that is applied on an `ndarray` in an element-by-element fashion. Several universal functions can be found the NumPy documentation here:\n",
    "https://docs.scipy.org/doc/numpy-1.13.0/reference/ufuncs.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list x =  [0, 1, 2, 3, 4]\n",
      "list y =  [5, 6, 7, 8, 9]\n",
      "x + y =  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# Arrays are different than lists in another way:\n",
    "# x and y are lists\n",
    "\n",
    "x = list(range(5))\n",
    "y = list(range(5,10))\n",
    "print (\"list x = \", x)\n",
    "print (\"list y = \", y)\n",
    "print (\"x + y = \", x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.array xn = [0 1 2 3 4]\n",
      "np.array xn = [5 6 7 8 9]\n",
      "xn + yn =  [ 5  7  9 11 13]\n"
     ]
    }
   ],
   "source": [
    "# now lets try with NumPy arrays:\n",
    "xn = np.array(x)\n",
    "yn = np.array(y)\n",
    "print ('np.array xn =', xn)\n",
    "print ('np.array xn =', yn)\n",
    "print (\"xn + yn = \", xn + yn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  7,  9, 11, 13])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# + for np.arrays is a wrapper around the function np.add\n",
    "np.add(xn,yn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4]\n",
      "[ 0  3  6  9 12]\n"
     ]
    }
   ],
   "source": [
    "# An array is a sequence that can be manipulated easily\n",
    "# An arithmatic operation is applied to each element individually\n",
    "# When two arrays are added, they must have the same size \n",
    "# (otherwise they might be broadcasted)\n",
    "\n",
    "print (3* x)\n",
    "print (3 * xn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Join, add, concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "[5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print(xn)\n",
    "print(yn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "# if you need to join numpy arrays, try hstack, vstack, column_stack, or concatenate\n",
    "print (np.hstack((xn,yn)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "print (np.vstack((xn,yn)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 5]\n",
      " [1 6]\n",
      " [2 7]\n",
      " [3 8]\n",
      " [4 9]]\n"
     ]
    }
   ],
   "source": [
    "print (np.column_stack((xn,yn)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print (np.concatenate((xn, yn), axis = 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1' '2' 'cat' '4']\n",
      "<U21\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "ufunc 'add' did not contain a loop with signature matching types dtype('<U21') dtype('<U21') dtype('<U21')",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-42-d58ffc54bf4e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# results in error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: ufunc 'add' did not contain a loop with signature matching types dtype('<U21') dtype('<U21') dtype('<U21')"
     ]
    }
   ],
   "source": [
    "# the elements of an array must be of a type that is valid to perform\n",
    "# a specific mathematical operation on\n",
    "\n",
    "data = np.array([1,2,'cat', 4])\n",
    "print(data)\n",
    "print(data.dtype)\n",
    "print (data+1)  # results in error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating arrays with 2 axis:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6]]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This list has two dimensions\n",
    "list3 = [[1, 2, 3],\n",
    "         [4, 5, 6]]\n",
    "list3 # nested list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# data = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "data = np.array(list3)\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Attributes of a multidim array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dimensions: 2\n",
      "Shape: (2, 3)\n",
      "Size: 6\n"
     ]
    }
   ],
   "source": [
    "print('Dimensions:',data.ndim)\n",
    "print ('Shape:',data.shape)\n",
    "print('Size:', data.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transpose:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can also transpose an array Matrix with either np.transpose(arr)\n",
    "# or arr.T\n",
    "print ('Transpose:')\n",
    "data.T\n",
    "\n",
    "# print (list3.T) # note, this would not work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other ways to create NumPy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.arange() is similar to built in range()\n",
    "# Creates array with a range of consecutive numbers\n",
    "# starts at 0 and step=1 if not specified. Exclusive of stop.\n",
    "\n",
    "np.arange(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Array increasing from start to end: np.arange(start, end)\n",
    "np.arange(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array increasing from start to end by step: np.arange(start, end, step)\n",
    "# The range always includes start but excludes end\n",
    "np.arange(1, 10, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0]], dtype=int8)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Returns a new array of specified size, filled with zeros.\n",
    "array=np.zeros((2,5), dtype=np.int8)\n",
    "array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.0,  1.0,  1.0,  1.0,  1.0],\n",
       "       [ 1.0,  1.0,  1.0,  1.0,  1.0]], dtype=float128)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Returns a new array of specified size, filled with ones.\n",
    "array=np.ones((2,5), dtype=np.float128)\n",
    "array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 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.]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Returns the identity matrix of specific squared size\n",
    "array = np.eye(5)\n",
    "array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some useful indexing strategies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### There are two main types of indexing: Integer and Boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([[1, 2], [3, 4], [5, 6]]) \n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Integer indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# first element is  the row, 2nd element is the column\n",
    "print(x[1,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "print(x[1:,:]) # all rows after first, all columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 6]\n"
     ]
    }
   ],
   "source": [
    "# first list contains  row indices, 2nd element contains column indices\n",
    "idx = x[[0,1,2], [0,1,1]]  # create index object\n",
    "print (idx)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Comparison operator, find all values greater than 3:\n",
      "\n",
      "[[False False]\n",
      " [False  True]\n",
      " [ True  True]]\n"
     ]
    }
   ],
   "source": [
    "print('Comparison operator, find all values greater than 3:\\n')\n",
    "print(x>3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boolean indexing, only extract elements greater than 3:\n",
      "\n",
      "[4 5 6]\n"
     ]
    }
   ],
   "source": [
    "print('Boolean indexing, only extract elements greater than 3:\\n')\n",
    "print(x[x>3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False False False False False  True  True  True  True]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([6, 7, 8, 9])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "mask = arr>5\n",
    "print(mask)\n",
    "arr[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Functions any / all\n",
    "print( np.any( arr==9 ) )\n",
    "print( np.all( arr>-1 ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra NumPy array methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]\n",
      "Reshaped:\n",
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]]\n"
     ]
    }
   ],
   "source": [
    "# Reshape is used to change the shape\n",
    "a = np.arange(0, 15)\n",
    "\n",
    "print('Original:',a)\n",
    "a = a.reshape(3, 5)\n",
    "# a = np.arange(0, 15).reshape(3, 5)  # same thing\n",
    "\n",
    "print ('Reshaped:')\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]]\n"
     ]
    }
   ],
   "source": [
    "# We can also easily find the sum, min, max, .. are easy\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum: 105\n",
      "Min: 0\n",
      "Max: 14\n"
     ]
    }
   ],
   "source": [
    "print ('Sum:',a.sum())\n",
    "print('Min:', a.min())\n",
    "print('Max:', a.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum along columns: [15 18 21 24 27]\n",
      "Sum along rows: [10 35 60]\n"
     ]
    }
   ],
   "source": [
    "print ('Sum along columns:',a.sum(axis=0))\n",
    "print ('Sum along rows:',a.sum(axis=1))\n",
    "\n",
    "# Note here axis specifies what dimension to \"collapse\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrray Axis\n",
    "<img src= \"https://github.com/ikhlaqsidhu/data-x/raw/master/imgsource/anatomyarray.png\">\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the cumulative product:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n",
      "[     1      2      6     24    120    720   5040  40320 362880]\n"
     ]
    }
   ],
   "source": [
    "print (np.arange(1, 10))\n",
    "print (np.cumprod(np.arange(1, 10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the cumulative sum:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print (np.arange(1, 10))\n",
    "np.cumsum((np.arange(1, 10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating a 3D array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2  3  4  5  6  7]\n",
      "  [ 8  9 10 11 12 13 14 15]\n",
      "  [16 17 18 19 20 21 22 23]\n",
      "  [24 25 26 27 28 29 30 31]\n",
      "  [32 33 34 35 36 37 38 39]\n",
      "  [40 41 42 43 44 45 46 47]]\n",
      "\n",
      " [[48 49 50 51 52 53 54 55]\n",
      "  [56 57 58 59 60 61 62 63]\n",
      "  [64 65 66 67 68 69 70 71]\n",
      "  [72 73 74 75 76 77 78 79]\n",
      "  [80 81 82 83 84 85 86 87]\n",
      "  [88 89 90 91 92 93 94 95]]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(0, 96).reshape(2, 6, 8)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 48  50  52  54  56  58  60  62]\n",
      " [ 64  66  68  70  72  74  76  78]\n",
      " [ 80  82  84  86  88  90  92  94]\n",
      " [ 96  98 100 102 104 106 108 110]\n",
      " [112 114 116 118 120 122 124 126]\n",
      " [128 130 132 134 136 138 140 142]]\n",
      "---\n",
      "[[120 126 132 138 144 150 156 162]\n",
      " [408 414 420 426 432 438 444 450]]\n"
     ]
    }
   ],
   "source": [
    "# The same methods typically apply in multiple dimensions\n",
    "print (a.sum(axis = 0))\n",
    "print ('---')\n",
    "print (a.sum(axis = 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More ufuncs and Basic Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the coolest parts of NumPy is the ability for you to run mathematical operations on top of arrays. Here are some basic operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  [11 12 13 14 15 16 17 18 19 20]\n",
      "b =  [0 1 2 3 4 5 6 7 8 9]\n",
      "[11 13 15 17 19 21 23 25 27 29]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(11, 21)\n",
    "b = np.arange(0, 10)\n",
    "print (\"a = \",a)\n",
    "print (\"b = \",b)\n",
    "print (a + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,  12,  26,  42,  60,  80, 102, 126, 152, 180])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([121, 144, 169, 196, 225, 256, 289, 324, 361, 400])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even do things like matrix operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "780"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dot(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c = \n",
      " [[1 2]\n",
      " [3 4]]\n",
      "\n",
      "d = \n",
      " [[5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "# Matrix multiplication\n",
    "c = np.arange(1,5).reshape(2,2)\n",
    "print (\"c = \\n\", c)\n",
    "print()\n",
    "d = np.arange(5,9).reshape(2,2)\n",
    "print (\"d = \\n\", d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[23 34]\n",
      " [31 46]]\n"
     ]
    }
   ],
   "source": [
    "print (d.dot(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[23, 34],\n",
       "       [31, 46]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(d,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3.19525402  3.86075747  3.4110535   3.17953273  2.6946192   3.58357645\n",
      "  2.75034885  4.567092    4.85465104  2.53376608]\n",
      "\n",
      "[ 1.56889614  0.75267411  0.83943285  2.59825415  0.07368535]\n"
     ]
    }
   ],
   "source": [
    "# Radom numbers\n",
    "np.random.seed(0)  # set the seed to zero for reproducibility\n",
    "print(np.random.uniform(1,5,10))   # 10 random uniform numbers from 1 to 5\n",
    "print()\n",
    "print (np.random.exponential(1,5)) # 5 random exp numbers with rate 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.0871293   0.0202184   0.83261985  0.77815675]\n",
      " [ 0.87001215  0.97861834  0.79915856  0.46147936]]\n"
     ]
    }
   ],
   "source": [
    "print (np.random.random(8).reshape(2,4)) #8 random 0-1 in a 2 x 4 array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to learn more about \"random\" numbers in NumPy go to: https://docs.scipy.org/doc/numpy-1.12.0/reference/routines.random.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Trignometric functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  0.    2.5   5.    7.5  10. ]\n"
     ]
    }
   ],
   "source": [
    "# linspace: Create an array with numbers from a to b \n",
    "# with n equally spaced numbers (inclusive)\n",
    "\n",
    "data = np.linspace(0,10,5)\n",
    "print (data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  [ 0.          1.57079633  3.14159265]\n",
      "\n",
      "sin(x) =  [  0.00000000e+00   1.00000000e+00   1.22464680e-16]\n"
     ]
    }
   ],
   "source": [
    "from numpy import pi\n",
    "x = np.linspace(0,pi, 3)\n",
    "print('x = ', x)\n",
    "print()\n",
    "print (\"sin(x) = \", np.sin(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original:\n",
      " [[ 0  1  2  3  4  5]\n",
      " [ 6  7  8  9 10 11]\n",
      " [12 13 14 15 16 17]\n",
      " [18 19 20 21 22 23]]\n",
      "\n",
      "Flattened:\n",
      " [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]\n"
     ]
    }
   ],
   "source": [
    "# flatten matrices using ravel()\n",
    "x = np.array(range(24))\n",
    "x = x.reshape(4,6)\n",
    "print('Original:\\n',x)\n",
    "print()\n",
    "x = x.ravel() # make it flat\n",
    "print ('Flattened:\\n',x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}