2-Estimations-and-Predictions/2.1_Intro_to_Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Introduction to Numpy\n",
    "\n",
    "\n",
    "[NumPy](http://www.numpy.org) , [SciPy](https://scipy.org) , [Scikit-Learn](http://scikit-learn.org/stable/index.html) are open-source Python based ecosystems for Mathematics, Science and Engineering. These packages gives the users access to complex mathematical and scientific algorithms/processes with easy to use tools. \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy Basics\n",
    "\n",
    "Numpy introduces new data types and data structures that allow for more efficient implementations of complex algorithms, e.g. matrix manipulation. This tutorial will cover some useful data structures introduced by numpy and how these differ from the normal python data structures.\n",
    "\n",
    "Lets start with Python Lists.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 2, 5, 10, True, False, 'hello', 'world']\n"
     ]
    }
   ],
   "source": [
    "#Lets define two python lists and few constants\n",
    "a = [1,2,3,4,5]\n",
    "b = [9,8,7,6,5]\n",
    "random = ['a','b','c',2,5,10,True,False,\"hello\",\"world\"]\n",
    "const1 = 10\n",
    "const2 = 5\n",
    "const3 = 2\n",
    "print(random)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A cool feature about lists, it is a collection of objects, and does not have to have all elements be of the same type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python allows for a few simple operations with lists:\n",
    "\n",
    "|  Python Expression | Results  | Description  |\n",
    "|:--------------------:|:-------------:|:-----------:|\n",
    "| len(a)             |          5  | Length  |\n",
    "|  a+b               | [1,2,3,4,5,6,7,8,9]  | Concatenation  |\n",
    "| for x in a: print x  |  1 2 3  | Iteration  | \n",
    "|[const1]\\*const2 | [10,10,10,10,10] | Repetition|\n",
    "| const3 in a | True | Membership |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Try them yourself !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating and Indexing Numpy Arrays\n",
    "\n",
    "Ok, Now lets see what we can do with a Numpy!\n",
    "Numpy introduces a new data structure similar to lists, called an array.\n",
    "First we need to import the numpy package (Hint: creating an alias for packages makes calling these objects faster in the future.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "#the 'as' creates an alias for the package being imported."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets create some numpy arrays, you can do this by casting lists or tuples to arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([9, 8, 7, 6, 5])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array(a)\n",
    "y = np.array(b)\n",
    "print(x)\n",
    "y "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see from above, when using print to view an array its looks just like a list, however when you simply view the object using the console, a bit more information is provided, telling you that it is indeed an array, but it only contains a single element... the list.\n",
    "\n",
    "This is because the numpy array is essentially a list of lists!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4 5]\n",
      " [9 8 7 6 5]]\n"
     ]
    }
   ],
   "source": [
    "z = np.array([a,b])\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "These lists do not need to be of the same length or type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([list([1, 2, 3, 4, 5]), list([9, 8, 7, 6, 5]),\n",
       "       list(['a', 'b', 'c', 'd']), list([True, False, True, True, False])],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = ['a','b','c','d']\n",
    "d = [True,False,True,True,False]\n",
    "arr = np.array([a,b,c,d])\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy also has multiple functions to create arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zeros\n",
      "[[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Zeros\")\n",
    "q = np.zeros((2,2))   # Create an array of all zeros\n",
    "print(q)              "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ones\n",
      "[[1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Ones\")\n",
    "r = np.ones((1,2))    # Create an array of all ones\n",
    "print(r)              "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full\n",
      "[[7.5 7.5]\n",
      " [7.5 7.5]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Full\")\n",
    "s = np.full((2,2), 7.5)  # Create a constant array\n",
    "print(s)      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arange\n",
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print(\"Arange\")\n",
    "t = np.arange(10) #create an array of 10 elements, which will start with a value of 0, and increment by 1\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random\n",
      "[[0.73263384 0.23002371]\n",
      " [0.29971586 0.84521875]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Random\")\n",
    "w = np.random.random((2,2))  # Create an array filled with random values\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to Python lists, numpy arrays can be sliced. Since arrays may be multidimensional, you must specify a slice for each dimension of the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Array\n",
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "Subset of array\n",
      "[[ 2  3]\n",
      " [ 6  7]\n",
      " [10 11]]\n"
     ]
    }
   ],
   "source": [
    "x1 = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "# zero index and is not right inclusive\n",
    "x2 = x1[:3, 1:3]\n",
    "print(\"Original Array\")\n",
    "print(x1)\n",
    "print(\"Subset of array\")\n",
    "print(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you index into numpy arrays using slicing, the resulting array view will always be a subarray of the original array. In contrast, integer array indexing allows you to construct arbitrary arrays using the data from another array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 5]\n",
      "[1 4 5]\n",
      "[2 2]\n",
      "[2 2]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "\n",
    "# An example of integer array indexing.\n",
    "# The returned array will have shape (3,) and \n",
    "print(a[[0, 1, 2], [0, 1, 0]])  # Prints \"[1 4 5]\" \n",
    "\n",
    "# The above example of integer array indexing is equivalent to this:\n",
    "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))  \n",
    "\n",
    "# When using integer array indexing, you can re-use the same\n",
    "# element from the source array:\n",
    "print(a[[0, 0], [1, 1]])  \n",
    "\n",
    "# Equivalent to the previous integer array indexing example\n",
    "print(np.array([a[0, 1], a[0, 1]])) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select the the first 2 rows and the first and last columns of a\n",
    "a[0:3, [0,2]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets try some simple math operation with numpy arrays.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array math\n",
    "\n",
    "Basic mathematical functions operate elementwise on arrays, and are available both as operator overloads and as functions in the numpy module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11 12 13 14 15]\n"
     ]
    }
   ],
   "source": [
    "print(x+10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike python lists, when adding a scalar/constant value to a numpy array, numpy will iterativly add the scalar value to each element. The same can be done with subtraction, multiplication and division! The only requirement is that the array only contain elements which are numbers (ints, doubles, floats, etc.).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  4  6  8 10]\n",
      " [18 16 14 12 10]]\n",
      "[0.9 0.8 0.7 0.6 0.5]\n",
      "[[-19 -18 -17 -16 -15]\n",
      " [-11 -12 -13 -14 -15]]\n",
      "[[ 1  4  9 16 25]\n",
      " [81 64 49 36 25]]\n"
     ]
    }
   ],
   "source": [
    "print(z*2)\n",
    "print(np.array(y/10))\n",
    "print(z-20)\n",
    "print(z**2) #Exponentiation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you were to try perform addition, subtraction or division on numpy arrays that contain non-numerical data types, numpy will throw an error. However, were you to attempt multiplication on such an array, numpy will replicate the data for each element in the array $ n $ number of times ( where $ n $ is the value being multiplied into the array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[list([1, 2, 3, 4, 5]) list([9, 8, 7, 6, 5]) list(['a', 'b', 'c', 'd'])\n",
      " list([True, False, True, True, False])] \n",
      "\n",
      "[list([1, 2, 3, 4, 5, 1, 2, 3, 4, 5]) list([9, 8, 7, 6, 5, 9, 8, 7, 6, 5])\n",
      " list(['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'])\n",
      " list([True, False, True, True, False, True, False, True, True, False])]\n"
     ]
    }
   ],
   "source": [
    "print(arr, '\\n')\n",
    "print(arr*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Created Arrays\n",
      "x : \n",
      " [[1. 2.]\n",
      " [3. 4.]]\n",
      "y : \n",
      " [[5. 6.]\n",
      " [7. 8.]]\n",
      "\n",
      "Addition\n",
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "\n",
      "Subtraction\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "\n",
      "Multiplication\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "\n",
      "Division\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "\n",
      "Square Root\n",
      "[[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "print(\"The Created Arrays\")\n",
    "print(\"x : \\n\", x)\n",
    "print(\"y : \\n\", y)\n",
    "print()\n",
    "print(\"Addition\")\n",
    "print(x + y)\n",
    "print(np.add(x, y))\n",
    "print()\n",
    "print(\"Subtraction\")\n",
    "print(x - y)\n",
    "print(np.subtract(x, y))\n",
    "print()\n",
    "print(\"Multiplication\")\n",
    "print(x * y)\n",
    "print(np.multiply(x, y))\n",
    "print()\n",
    "print(\"Division\")\n",
    "print(x / y)\n",
    "print(np.divide(x, y))\n",
    "print()\n",
    "print(\"Square Root\")\n",
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Numpy provides many useful mathematical functions that can be applied to the arrays. The full list can be found [here](https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.math.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python allows for a few simple operations with lists:\n",
    "\n",
    "|  Python Expression   | Description  |\n",
    "|:--------------------:|:-----------:|\n",
    "|sin(x)            |Apply sin function to each element|\n",
    "|sum(x)            |Add all the elements in the array|\n",
    "|mean(x)           |Calculate the mean of the values in array| \n",
    "|square(x)         |Square each element|\n",
    "|power(x,y)        |Put each element in x to the power of the element in y|\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#try some"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Useful Numpy Manipulation Functions\n",
    "\n",
    "Numpy also has various functions to work with arrays to make working with arrays easier.\n",
    "I will list a few, but the full list can be found [here](https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.array-manipulation.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.concatenate((x,y))) # Simply combines the arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Appending Arrays - Similar to concatenate, however has a few other parameters allowing for better control."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Default parameters\n",
      "[1. 2. 3. 4. 5. 6. 7. 8.]\n",
      "Changing the Axis for the merge: axis = 0\n",
      "[[1. 2.]\n",
      " [3. 4.]\n",
      " [5. 6.]\n",
      " [7. 8.]]\n",
      "Changing the Axis for the merge: axis = 1\n",
      "[[1. 2. 5. 6.]\n",
      " [3. 4. 7. 8.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Default parameters\")\n",
    "print(np.append(x,y)) #this appends array y to x\n",
    "print(\"Changing the Axis for the merge: axis = 0\")\n",
    "print(np.append(x,y,axis=0))\n",
    "print(\"Changing the Axis for the merge: axis = 1\")\n",
    "print(np.append(x,y,axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also functionality to delete objects from an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [3. 4.]]\n",
      "[3.]\n",
      "[[1. 2.]\n",
      " [3. 4.]]\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "print(np.delete(x,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting a unique list of elements for an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8]\n"
     ]
    }
   ],
   "source": [
    "z = np.array([1,2,3,4,2,5,3,7,8,8,6,4])\n",
    "print(np.unique(z))"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}