lectures/notebooks/Lecture_06_NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Fundamentals of Information Systems\n",
    "\n",
    "## Python Programming (for Data Science)\n",
    "\n",
    "### Master's Degree in Data Science\n",
    "\n",
    "#### Gabriele Tolomei\n",
    "<a href=\"mailto:gtolomei@math.unipd.it\">gtolomei@math.unipd.it</a><br/>\n",
    "University of Padua, Italy<br/>\n",
    "2018/2019<br/>\n",
    "November, 8 2018"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 6: Numerical Python (<code>numpy</code>)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What is <code>numpy</code>?\n",
    "\n",
    "-  It stands for <code>**num**</code>erical <code>**py**</code>thon, and is one of the core packages for numerical/scientific computing in Python. \n",
    "\n",
    "-  Most computational packages providing scientific functionality use <code>**numpy**</code> **array objects** as the building block for data exchange.\n",
    "\n",
    "-  You can find more about <code>**numpy**</code> on the official [website](http://www.numpy.org/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "As any other third-party module, the numpy module has to be imported before it can be used.\n",
    "If you installed Python with Anaconda, numpy would be just available to you.\n",
    "This is usually how numpy is imported and aliased. Although you could also\n",
    "use another syntax like 'from numpy import *', I strongly encourage you to define an alias,\n",
    "as this will help you to identify numpy's functions in your code.\n",
    "\"\"\"\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What is inside <code>numpy</code>?\n",
    "\n",
    "-  <code>**ndarray**</code>: an efficient multi-dimensional array providing fast array-oriented arithmetic operations.\n",
    "\n",
    "-  Mathematical functions for fast operations on entire arrays of data without having to write loops.\n",
    "\n",
    "-  Tools for reading array data from (writing array data to) disk and working with memory-mapped files.\n",
    "\n",
    "-  Linear algebra, random number generation, and Fourier transform capabilities.\n",
    "\n",
    "-  A C API for connecting <code>**numpy**</code> with libraries written in C, C++, or FORTRAN."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## General purpose <code>numpy</code>\n",
    "\n",
    "-  Because <code>**numpy**</code> provides an easy-to-use C API, it is straightforward to pass data to/from external libraries written in a low-level language.\n",
    "\n",
    "-  <code>**numpy**</code> itself does not provide modeling nor scientific functionality, but knowing of <code>**numpy**</code> basics will help you use tools with array-oriented semantics, like <code>**pandas**</code>.\n",
    "\n",
    "-  In this class, we will in fact use <code>**pandas**</code>, which is tailored to tabular data and also provides some more domain-specific functionality like time series manipulation, which is not present in <code>**numpy**</code>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Space Efficiency of <code>numpy</code>'s <code>ndarray</code>\n",
    "\n",
    "-  <code>**numpy**</code>'s importance for numerical computations in Python is due to its design for efficiency (especially when operating on large arrays of data).\n",
    "\n",
    "-  It internally stores data in a **contiguous** block of memory, independent of other built-in Python objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Space Efficiency of <code>numpy</code>'s <code>ndarray</code>\n",
    "<br/>\n",
    "<center>![](./img/ndarray_vs_list.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Time Efficiency of <code>numpy</code>'s <code>ndarray</code>\n",
    "\n",
    "-  <code>**ndarray**</code>s efficient memory occupation implies also computational **time efficiency**.\n",
    "\n",
    "-  Its library of algorithms mostly written in low-level C can operate on this memory without introducing any overhead due to type checking.\n",
    "\n",
    "-  <code>**numpy**</code> operations perform complex computations on entire arrays without the need for Python <code>**for**</code> loops (i.e., knowing the address of the memory block and the data type, it is just simple arithmetic).\n",
    "\n",
    "-  Spatial locality in memory access patterns results in performance gains notably due to the CPU cache (sequential locality, or locality of reference).\n",
    "\n",
    "-  Since items are stored contiguously in memory, <code>**numpy**</code> can take advantage of **vectorized instructions** provided by modern CPUs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Efficiency of <code>numpy</code>: a real example\n",
    "\n",
    "-  To validate the efficiency of <code>**numpy**</code> in contrast with built-in Python list, just try to run the code snippet below:\n",
    "```python\n",
    "# create a numpy array with 1M integers\n",
    "my_arr = np.arange(1000000) \n",
    "# create a built-in list with 1M integers\n",
    "my_list = list(range(1000000))\n",
    "# double each element of the numpy array\n",
    "my_arr2 = my_arr * 2\n",
    "# double each element of the built-in list\n",
    "my_list2 = [x * 2 for x in my_list] \n",
    "```\n",
    "-  <code>**numpy**</code>-based algorithms are expected to be **10 to 100** times faster than their pure Python counterparts and use significantly less memory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Scalar vs. Vector Processing\n",
    "\n",
    "Vector processing is also known as **S**ingle **I**nstruction **M**ultiple **D**ata (**SIMD**)\n",
    "<br />\n",
    "<center>![](./img/scalar_vs_simd.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# <code>ndarray</code>: A Multidimensional Array Object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Properties of <code>ndarray</code>\n",
    "\n",
    "-  A fast, flexible, generic multidimensional container for large homogeneous data sets in Python. \n",
    "\n",
    "-  Arrays enable you to perform mathematical operations on whole blocks of data using similar syntax to the equivalent operations between scalars.\n",
    "\n",
    "-  All the elements of an <code>**ndarray**</code> must be of the **same** type. \n",
    "\n",
    "-  Every array has a <code>**shape**</code>, a tuple indicating the size of each dimension, and a <code>**dtype**</code>, an object describing the data type of the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original data matrix =\n",
      "[[ 0.60412659  1.20847991 -1.03453903]\n",
      " [ 0.76247938 -0.6180134   1.12874354]]\n",
      "data matrix * 10 =\n",
      "[[  6.04126594  12.0847991  -10.34539031]\n",
      " [  7.62479376  -6.18013404  11.28743543]]\n",
      "(data matrix + data matrix) =\n",
      "[[ 1.20825319  2.41695982 -2.06907806]\n",
      " [ 1.52495875 -1.23602681  2.25748709]]\n"
     ]
    }
   ],
   "source": [
    "# Generate some random data over a 2x3 array (i.e., a matrix)\n",
    "data = np.random.randn(2, 3)\n",
    "# Print out data\n",
    "print(\"Original data matrix =\\n{}\".format(data))\n",
    "# Multiply each element of the matrix by a constant 10\n",
    "data10 = data * 10\n",
    "# Print out the new data matrix\n",
    "print(\"data matrix * 10 =\\n{}\".format(data10))\n",
    "# Sum two data matrices (i.e., the same as multiply each element by 2)\n",
    "data2 = data + data\n",
    "# Print out the new data matrix\n",
    "print(\"(data matrix + data matrix) =\\n{}\".format(data2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of data is: (2, 3)\n",
      "The type of objects contained in data is: float64\n"
     ]
    }
   ],
   "source": [
    "# Showing the shape of the ndarray object\n",
    "print(\"The shape of data is: {}\".format(data.shape))\n",
    "# Showing the type of objects contained in the ndarray object\n",
    "print(\"The type of objects contained in data is: {}\".format(data.dtype))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Creating <code>ndarray</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 42. ,   2.5,  73. ,   0. ,   3. ,   1. ])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Start from a built-in Python list\n",
    "data = [42, 2.5, 73, 0, 3, 1.0]\n",
    "# The corresponding numpy array can be obtained by calling the np.array function\n",
    "arr = np.array(data)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multidimensional array:\n",
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n",
      "Number of dimensions of the array: 2\n",
      "Shape of the array: (2, 4)\n",
      "Shape of the unidimensional array: float64\n",
      "Shape of the multidimensional array: int64\n"
     ]
    }
   ],
   "source": [
    "# Nested sequences, like a list of equal-length lists, \n",
    "# will be converted into a multidimensional array\n",
    "multi_data = [[1, 2, 3, 4], [5, 6, 7, 8]]\n",
    "# Convert the list of list into a (multidimensional) numpy array\n",
    "multi_arr = np.array(multi_data)\n",
    "print(\"Multidimensional array:\\n{}\".format(multi_arr))\n",
    "print(\"Number of dimensions of the array: {}\".format(multi_arr.ndim))\n",
    "print(\"Shape of the array: {}\".format(multi_arr.shape))\n",
    "# Unless explicitly specified (more on this later), np.array tries to infer \n",
    "# a good data type for the array that it creates. \n",
    "# The data type is stored in a special dtype metadata object's field.\n",
    "print(\"Shape of the unidimensional array: {}\".format(arr.dtype))\n",
    "print(\"Shape of the multidimensional array: {}\".format(multi_arr.dtype))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating a unidimensional array with 5 zeros: [ 0.  0.  0.  0.  0.]\n",
      "Creating a multidimensional array (i.e., 3x2 matrix) with all zeros:\n",
      "[[ 0.  0.]\n",
      " [ 0.  0.]\n",
      " [ 0.  0.]]\n",
      "Creating two empty multidimensional arrays (i.e., 3x4 matrix):\n",
      "[[[  2.31584178e+077   2.31584178e+077   6.42285340e-323   0.00000000e+000]\n",
      "  [  0.00000000e+000   0.00000000e+000   0.00000000e+000   0.00000000e+000]\n",
      "  [  0.00000000e+000   0.00000000e+000   0.00000000e+000   0.00000000e+000]]\n",
      "\n",
      " [[  0.00000000e+000   0.00000000e+000   0.00000000e+000   1.14411728e-308]\n",
      "  [  2.31584178e+077   2.31584178e+077   2.47032823e-323   0.00000000e+000]\n",
      "  [  0.00000000e+000   0.00000000e+000   2.31584178e+077   2.00390288e+000]]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "In addition to np.array, there are a number of other functions for creating new arrays.\n",
    "As examples, 'zeros' and 'ones' create arrays of 0's or 1's, respectively, \n",
    "with a given length or shape. \n",
    "'empty' creates an array without initializing its values to any particular value. \n",
    "To create a higher dimensional array with these methods, pass a tuple for the shape.\n",
    "\"\"\"\n",
    "print(\"Creating a unidimensional array with 5 zeros: {}\".format(np.zeros(5)))\n",
    "print(\"Creating a multidimensional array (i.e., 3x2 matrix) with all zeros:\\n{}\"\\\n",
    "      .format(np.zeros((3,2))))\n",
    "print(\"Creating two empty multidimensional arrays (i.e., 3x4 matrix):\\n{}\"\\\n",
    "      .format(np.empty((2, 3, 4))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 'arange' is an array-valued version of the built-in Python 'range' function\n",
    "np.arange(16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Table of <code>numpy</code> Functions to Create <code>ndarray</code>\n",
    "\n",
    "<center>![](./img/np_creation.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data Types for <code>ndarray</code>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data Type: <code>dtype</code>\n",
    "\n",
    "-  The data type or <code>**dtype**</code> is a special object containing the information (or **metadata**) that the ndarray needs to interpret a chunk of memory as a particular type of data.\n",
    "\n",
    "-  In most cases, <code>**dtype**</code>s provide a mapping directly onto an underlying disk or memory representation, which makes it easy to read and write binary streams of data. \n",
    "\n",
    "-  Numerical dtypes are named the same way as built-in numerics, yet they also contain the number of bits per element. E.g., <code>**float64**</code> is the <code>**numpy**</code> equivalent of a standard double-precision floating point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr1 data type is: float64\n",
      "arr2 data type is: int32\n"
     ]
    }
   ],
   "source": [
    "# Explicitly declare the dtype of the array at definition time\n",
    "# float64\n",
    "arr1 = np.array([1, 2, 3], dtype=np.float64)\n",
    "# int32\n",
    "arr2 = np.array([1, 2, 3], dtype=np.int32)\n",
    "print(\"arr1 data type is: {}\".format(arr1.dtype))\n",
    "print(\"arr2 data type is: {}\".format(arr2.dtype))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Table of <code>dtype</code> (1 of 2)\n",
    "\n",
    "<center>![](./img/np_dtypes_1.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Table of <code>dtype</code> (2 of 2)\n",
    "\n",
    "<center>![](./img/np_dtypes_2.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Casting to a specific <code>dtype</code> using <code>astype</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The (inferred) dtype for the just defined numpy array is: int64\n",
      "The dtype for the cast numpy array is: float64\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Sometimes it may be useful to explicitly convert or cast an array \n",
    "from one dtype to another using ndarray's 'astype' method.\n",
    "\"\"\"\n",
    "# Let's define an array using the numpy's array method\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print(\"The (inferred) dtype for the just defined numpy array is: {}\".format(arr.dtype))\n",
    "# Now, let's convert the inferred dtype (int64) into float64 using 'astype'\n",
    "float_arr = arr.astype(np.float64)\n",
    "print(\"The dtype for the cast numpy array is: {}\".format(float_arr.dtype))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original array is: [  3.7  -1.2  -2.6   0.5  12.9  10.1]\n",
      "The array cast to integer is: [ 3 -1 -2  0 12 10]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Sometimes it may be useful to explicitly convert or cast an array \n",
    "from one dtype to another using ndarray's 'astype' method.\n",
    "\"\"\"\n",
    "# In the example above, integers are cast to floating point. \n",
    "# What if we cast some floating point numbers to be of integer dtype?\n",
    "# Let's create the numpy array from a list of float numbers\n",
    "arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])\n",
    "print(\"The original array is: {}\".format(arr))\n",
    "print(\"The array cast to integer is: {}\".format(arr.astype(np.int32)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original array cast to string is: [  1.25  -9.6   42.  ]\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: 'h7-25'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-e39493940eea>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;31m# a ValueError will be raised.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0mwrong_numeric_strings\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'1.25'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'-9.6'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'h7-25'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'42'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstring_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The original array cast to string is: {}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwrong_numeric_strings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'h7-25'"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "If you have an array of strings representing numbers, \n",
    "you can use 'astype' to convert them to numeric form.\n",
    "\"\"\"\n",
    "numeric_strings = np.array(['1.25', '-9.6', '42'], dtype=np.string_)\n",
    "# Note that we use 'float' instead of 'np.float64',\n",
    "# as numpy aliases the Python types to its own equivalent dtypes.\n",
    "print(\"The original array cast to string is: {}\".format(numeric_strings.astype(float)))\n",
    "# If casting fails for some reason (like a string that cannot be converted to float64), \n",
    "# a ValueError will be raised.\n",
    "wrong_numeric_strings = np.array(['1.25', '-9.6', 'h7-25', '42'], dtype=np.string_)\n",
    "print(\"The original array cast to string is: {}\".format(wrong_numeric_strings.astype(float)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## About <code>astype</code>\n",
    "\n",
    "Calling <code>**astype**</code> **always** returns a copy of the original numpy array (even if we apply a \"dummy\" casting, i.e., if the new <code>**dtype**</code> we want to cast the array to is the same of the original, old <code>**dtype**</code>). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operations between arrays and scalars\n",
    "\n",
    "\n",
    "-  <code>**numpy**</code> arrays enables you to express many kinds of \"batched\" data processing tasks as concise array expressions, instead of writing <code>**for**</code> loops. \n",
    "\n",
    "-  This practice is commonly referred to as **vectorization**. \n",
    "\n",
    "-  In general, vectorized array operations is one or two (or more) orders of magnitude faster than their pure Python equivalents.  \n",
    "\n",
    "-  Any arithmetic operations between equal-size arrays applies the operation elementwise.\n",
    "\n",
    "-  Operations between differently sized arrays is called **broadcasting** but won't be further discussed here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Consider the following 2x3 array:\n",
      "[[ 1.  2.  3.]\n",
      " [ 4.  5.  6.]]\n",
      "Square the elements of the original array:\n",
      "[[  1.   4.   9.]\n",
      " [ 16.  25.  36.]]\n",
      "Compute the reciprocal of the elements of the original array:\n",
      "[[ 1.          0.5         0.33333333]\n",
      " [ 0.25        0.2         0.16666667]]\n",
      "Compute the square root of the elements of the original array:\n",
      "[[ 1.          1.41421356  1.73205081]\n",
      " [ 2.          2.23606798  2.44948974]]\n"
     ]
    }
   ],
   "source": [
    "# Let's define a simple 2x3 numpy array\n",
    "arr = np.array([[1., 2., 3.], [4., 5., 6.]])\n",
    "print(\"Consider the following {}x{} array:\\n{}\"\\\n",
    "      .format(arr.shape[0], arr.shape[1], arr))\n",
    "# Square the values contained in the original array\n",
    "arr_squared = arr * arr\n",
    "print(\"Square the elements of the original array:\\n{}\"\\\n",
    "      .format(arr_squared))\n",
    "\n",
    "# Arithmetic operations with scalars are as you would expect, \n",
    "# propagating the value to each element\n",
    "reciprocal_arr = 1/arr\n",
    "print(\"Compute the reciprocal of the elements of the original array:\\n{}\"\\\n",
    "      .format(reciprocal_arr))\n",
    "sqrt_arr = arr ** 0.5\n",
    "print(\"Compute the square root of the elements of the original array:\\n{}\"\\\n",
    "      .format(sqrt_arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Basic Indexing and Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original numpy array is: [33 16 49 21 11 17 36 45 35 43]\n",
      "Accessing the 6-th element of the array: 17\n",
      "Extracting from the 6-th to the 8-th element of the array: [17 36 45]\n",
      "Now the numpy array is: [33 16 49 21 11 12 12 12 35 43]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "numpy array indexing is a rich topic, as there are many ways \n",
    "you may want to select a subset of your data or individual elements. \n",
    "One-dimensional arrays are simple; on the surface they act similarly to Python lists.\n",
    "\"\"\"\n",
    "# Create an ndarray of 10 random integers in the range [0, 50)\n",
    "arr = np.random.randint(low=0, high=50, size=10)\n",
    "print(\"Original numpy array is: {}\".format(arr))\n",
    "print(\"Accessing the 6-th element of the array: {}\".format(arr[5]))\n",
    "print(\"Extracting from the 6-th to the 8-th element of the array: {}\".format(arr[5:8]))\n",
    "# Assigning a new value to a slice is \"broadcasted\" to all the elements of the slice.\n",
    "arr[5:8] = 12\n",
    "print(\"Now the numpy array is: {}\".format(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sliced Python list = [5, 6, 7]\n",
      "Sliced numpy array = [5 6 7]\n",
      "Sliced Python list = [12, 12, 12]\n",
      "Original Python list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Sliced numpy array = [12 12 12]\n",
      "Original numpy arr = [ 0  1  2  3  4 12 12 12  8  9]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Differently from Python's built-in lists, numpy array slices are views on the original array.\n",
    "This means that the data is not (shallow-)copied, \n",
    "and any modifications to the view will be reflected in the source array.\n",
    "\"\"\"\n",
    "# Define a Python standard list containing the first 10 non-negative integers [0, 1, ..., 9]\n",
    "py_list = [x for x in range(10)]\n",
    "# Define a numpy array with the same elements\n",
    "arr = np.arange(10)\n",
    "# Slicing the Python list\n",
    "sliced_list = py_list[5:8]\n",
    "print(\"Sliced Python list = {}\".format(sliced_list))\n",
    "# Slicing the numpy array\n",
    "sliced_arr = arr[5:8]\n",
    "print(\"Sliced numpy array = {}\".format(sliced_arr))\n",
    "# Changing references of the Python sliced list won't change the original list\n",
    "sliced_list = [12 for i in sliced_list]\n",
    "print(\"Sliced Python list = {}\".format(sliced_list))\n",
    "print(\"Original Python list = {}\".format(py_list))\n",
    "# Changing references of the sliced numpy array will reflect to the original array\n",
    "sliced_arr[:] = 12\n",
    "print(\"Sliced numpy array = {}\".format(sliced_arr))\n",
    "print(\"Original numpy arr = {}\".format(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sliced numpy array = [12 12 12]\n",
      "Original numpy arr = [0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "If you want a copy of a slice of a numpy array instead of a view, \n",
    "you will need to explicitly copy the array; for example arr[5:8].copy()\n",
    "\"\"\"\n",
    "arr = np.arange(10)\n",
    "sliced_arr = arr[5:8].copy()\n",
    "# Changing references of the sliced numpy array will NOT reflect to the original array\n",
    "sliced_arr[:] = 12\n",
    "print(\"Sliced numpy array = {}\".format(sliced_arr))\n",
    "print(\"Original numpy arr = {}\".format(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original numpy array is:\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "The third element of the original array is: [7 8 9]\n",
      "The third element of the first array is: 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "With higher dimensional arrays, you have many more options. \n",
    "In a two-dimensional array, the elements at each index are no longer scalars \n",
    "but rather one-dimensional arrays.\n",
    "\"\"\"\n",
    "# Consider the following 3x3 matrix defined as a two-dimensional array\n",
    "arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "print(\"Original numpy array is:\\n{}\".format(arr2d))\n",
    "# Accessing the 2-nd element of the matrix above\n",
    "print(\"The third element of the original array is: {}\".format(arr2d[2]))\n",
    "# Thus, individual elements can be accessed recursively. \n",
    "# This is a bit too cumbersome, so you can pass a comma-separated list of indices. \n",
    "print(\"The third element of the first array is: {}\".format(arr2d[0][2]))\n",
    "arr2d[0][2] == arr2d[0, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indexing on a 2-d Array\n",
    "\n",
    "<center>![](./img/np_indexing.png)</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sliced array (matrix):\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "Sliced array (matrix):\n",
      "[[2 3]\n",
      " [5 6]]\n",
      "Sliced array (matrix):\n",
      "[4 5]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Higher dimensional numpy arrays give you more options,\n",
    "as you can slice one or more axes and also mix integers. \n",
    "Consider the 2D array above, arr2d. Slicing this array is a bit different\n",
    "\"\"\"\n",
    "print(\"Sliced array (matrix):\\n{}\".format(arr2d[:2]))\n",
    "\"\"\"\n",
    "As you can see, it has sliced along axis 0, the first axis. \n",
    "A slice, therefore, selects a range of elements along an axis. \n",
    "You can pass multiple slices just like you can pass multiple indexes\n",
    "\"\"\"\n",
    "# Extract the first two elements along axis 0 (i.e., the first two rows)\n",
    "# and every element except the first along axis 1 (i.e., the second and third columns)\n",
    "print(\"Sliced array (matrix):\\n{}\".format(arr2d[:2, 1:]))\n",
    "# When slicing like this, you always obtain array views of the same number of dimensions. \n",
    "# By mixing integer indexes and slices, you get lower dimensional slices\n",
    "# Access the whole second element along axis 0 and the first two along axis 1.\n",
    "print(\"Sliced array (matrix):\\n{}\".format(arr2d[1, :2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sliced array (matrix):\n",
      "[[1]\n",
      " [4]\n",
      " [7]]\n",
      "New array (matrix):\n",
      "[[1 0 0]\n",
      " [4 0 0]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Note that a colon by itself means to take the entire axis, \n",
    "so you can slice only higher dimensional axes by doing as follows\n",
    "\"\"\"\n",
    "# Extract the first column\n",
    "print(\"Sliced array (matrix):\\n{}\".format(arr2d[:, :1]))\n",
    "# Of course, assigning to a slice expression assigns to the whole selection\n",
    "arr2d[:2, 1:] = 0\n",
    "print(\"New array (matrix):\\n{}\".format(arr2d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Slicing on a 2-d Array\n",
    "\n",
    "<center>![](./img/np_slicing.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Boolean Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original input data is:\n",
      "[[-0.7719735  -0.54500994  1.08807583  1.49070231]\n",
      " [-0.98309067 -0.70861066 -1.93274927 -1.79011088]\n",
      " [ 1.63070203 -0.53315322  0.58725735  0.17322339]\n",
      " [-0.9051374  -0.6947978  -1.96765755  0.53994032]\n",
      " [-0.24636087  0.33501854  0.71853993  0.89458756]\n",
      " [-1.23836331 -1.69812044  0.50381849 -1.61415737]\n",
      " [ 0.7691585   0.8033165   2.0940385  -0.49227147]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ True, False, False,  True, False, False, False], dtype=bool)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Let's consider an array containing some data and an array of names with duplicates. \n",
    "We generate some random normally distributed data with the 'randn' function in numpy.random\n",
    "\"\"\"\n",
    "# Random, normally distributed 7x4 data matrix\n",
    "data = np.random.randn(7, 4)\n",
    "print(\"The original input data is:\\n{}\".format(data))\n",
    "# numpy array containing \"names\"\n",
    "names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\n",
    "\"\"\"\n",
    "Suppose each name corresponds to a row in the data array,\n",
    "and we want to select all the rows with corresponding name 'Bob'. \n",
    "Like arithmetic operations, comparisons (such as ==) with arrays are also vectorized. \n",
    "Thus, comparing names with the string 'Bob' yields a boolean array\n",
    "\"\"\"\n",
    "names == 'Bob'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.7719735 , -0.54500994,  1.08807583,  1.49070231],\n",
       "       [-0.9051374 , -0.6947978 , -1.96765755,  0.53994032]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "The boolean array above can be passed when indexing the array\n",
    "\"\"\"\n",
    "data[names == 'Bob']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boolean indexing, 3rd and 4th columns only:\n",
      "[[ 1.08807583  1.49070231]\n",
      " [-1.96765755  0.53994032]]\n",
      "Boolean indexing, 2nd column only:\n",
      "[-0.54500994 -0.6947978 ]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "The boolean array must be of the same length as the axis it is indexing. \n",
    "You can even mix and match boolean arrays with slices or integers (or sequences of integers)\n",
    "\"\"\"\n",
    "# Extract all the rows indexed by the boolean array yet limited to 3rd and 4th columns\n",
    "print(\"Boolean indexing, 3rd and 4th columns only:\\n{}\".format(data[names == 'Bob', 2:]))\n",
    "# Extract all the rows indexed by the boolean array yet limited to 2nd column\n",
    "print(\"Boolean indexing, 2nd column only:\\n{}\".format(data[names == 'Bob', 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.98309067, -0.70861066, -1.93274927, -1.79011088],\n",
       "       [ 1.63070203, -0.53315322,  0.58725735,  0.17322339],\n",
       "       [-0.24636087,  0.33501854,  0.71853993,  0.89458756],\n",
       "       [-1.23836331, -1.69812044,  0.50381849, -1.61415737],\n",
       "       [ 0.7691585 ,  0.8033165 ,  2.0940385 , -0.49227147]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "To select everything but 'Bob', you can either use '!=' or negate the condition using '~'\n",
    "\"\"\"\n",
    "data[~(names == 'Bob')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Masked data:\n",
      "[[-0.7719735  -0.54500994  1.08807583  1.49070231]\n",
      " [ 1.63070203 -0.53315322  0.58725735  0.17322339]\n",
      " [-0.9051374  -0.6947978  -1.96765755  0.53994032]\n",
      " [-0.24636087  0.33501854  0.71853993  0.89458756]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "To select more than one names to combine multiple boolean conditions, \n",
    "use boolean arithmetic operators like '&' (and) and '|' (or)\n",
    "NOTE: The Python keywords 'and' and 'or' DO NOT work with boolean arrays!!!\n",
    "Selecting data from an array by boolean indexing always creates a copy of the data, \n",
    "even if the returned array is unchanged.\n",
    "\"\"\"\n",
    "mask = (names == 'Bob') | (names == 'Will')\n",
    "print(\"Masked data:\\n{}\".format(data[mask]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.        ,  0.        ,  1.08807583,  1.49070231],\n",
       "       [ 0.        ,  0.        ,  0.        ,  0.        ],\n",
       "       [ 1.63070203,  0.        ,  0.58725735,  0.17322339],\n",
       "       [ 0.        ,  0.        ,  0.        ,  0.53994032],\n",
       "       [ 0.        ,  0.33501854,  0.71853993,  0.89458756],\n",
       "       [ 0.        ,  0.        ,  0.50381849,  0.        ],\n",
       "       [ 0.7691585 ,  0.8033165 ,  2.0940385 ,  0.        ]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Setting values with boolean arrays works in a common-sense way. \n",
    "To set all of the negative values in 'data' to '0' we need only to do the following.\n",
    "\"\"\"\n",
    "data[data < 0] = 0\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.        ,  5.        ,  5.        ,  5.        ],\n",
       "       [ 0.        ,  0.        ,  0.        ,  0.        ],\n",
       "       [ 5.        ,  5.        ,  5.        ,  5.        ],\n",
       "       [ 5.        ,  5.        ,  5.        ,  5.        ],\n",
       "       [ 5.        ,  5.        ,  5.        ,  5.        ],\n",
       "       [ 0.        ,  0.        ,  0.50381849,  0.        ],\n",
       "       [ 0.7691585 ,  0.8033165 ,  2.0940385 ,  0.        ]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "Setting whole rows or columns using a 1D boolean array is also easy.\n",
    "\"\"\"\n",
    "data[names != 'Joe'] = 5\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Transposing Arrays and Swapping Axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original numpy array is: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]\n",
      "The reshaped numpy array is:\n",
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]]\n",
      "The transposed numpy array is:\n",
      "[[ 0  5 10]\n",
      " [ 1  6 11]\n",
      " [ 2  7 12]\n",
      " [ 3  8 13]\n",
      " [ 4  9 14]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Transposing is a special form of reshaping which returns a view on the underlying data\n",
    "without copying anything. \n",
    "Arrays have the transpose method and also the special 'T' attribute.\n",
    "\"\"\"\n",
    "# Let's define a 1-d numpy array\n",
    "arr = np.arange(15)\n",
    "print(\"The original numpy array is: {}\".format(arr))\n",
    "reshaped_arr = arr.reshape((3, 5))\n",
    "print(\"The reshaped numpy array is:\\n{}\".format(reshaped_arr))\n",
    "transposed_arr = reshaped_arr.T\n",
    "print(\"The transposed numpy array is:\\n{}\".format(transposed_arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original matrix is:\n",
      "[[ 0.53942833 -0.60514056  0.17707711]\n",
      " [ 1.35496875 -0.61242005  1.15398291]\n",
      " [ 1.78242713  0.02099927  0.3451653 ]\n",
      " [-0.5397399   0.55667071  2.01884349]]\n",
      "The result of the dot product is:\n",
      "[[ 5.59528889 -1.41926772  1.18471281]\n",
      " [-1.41926772  1.05157666  0.31720044]\n",
      " [ 1.18471281  0.31720044  5.55790097]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "When doing matrix computations, you will do this very often, \n",
    "like for example computing the dot matrix product XTX using np.dot\n",
    "\"\"\"\n",
    "# Create a 4x3 matrix\n",
    "matrix = np.random.randn(4, 3)\n",
    "print(\"The original matrix is:\\n{}\".format(matrix))\n",
    "dot_product = np.dot(matrix.T, matrix)\n",
    "print(\"The result of the dot product is:\\n{}\".format(dot_product))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Universal Functions: Fast Element-wise Array Functions\n",
    "\n",
    "-  A universal function, or <code>**ufunc**</code>, is a function that performs elementwise operations on data in <code>**ndarray**</code>s.\n",
    "\n",
    "-  You can think of them as fast vectorized wrappers for simple functions that take one or more scalar values and produce one or more scalar results.\n",
    "\n",
    "-  In case of binary universal functions, the shape of the input arrays **must be the same**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original array is: [0 1 2 3 4 5 6 7 8 9]\n",
      "The squared-root array is: [ 0.          1.          1.41421356  1.73205081  2.          2.23606798\n",
      "  2.44948974  2.64575131  2.82842712  3.        ]\n",
      "The exp array is: [  1.00000000e+00   2.71828183e+00   7.38905610e+00   2.00855369e+01\n",
      "   5.45981500e+01   1.48413159e+02   4.03428793e+02   1.09663316e+03\n",
      "   2.98095799e+03   8.10308393e+03]\n",
      "x = [-1.60788496  1.3027705   1.29542805 -0.5510918   1.55611235]\n",
      "y = [-0.32853292 -0.36326418  0.19170485  0.15990394  0.76457901]\n",
      "Element-wise maximum between x's and y's elements: [-0.32853292  1.3027705   1.29542805  0.15990394  1.55611235]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Many ufuncs are simple elementwise unary transformations, like 'sqrt' or 'exp'.\n",
    "\"\"\"\n",
    "arr = np.arange(10)\n",
    "print(\"The original array is: {}\".format(arr))\n",
    "sqrt_arr = np.sqrt(arr)\n",
    "print(\"The squared-root array is: {}\".format(sqrt_arr))\n",
    "exp_arr = np.exp(arr)\n",
    "print(\"The exp array is: {}\".format(exp_arr))\n",
    "\"\"\"\n",
    "Other functions, such as 'add' or 'maximum', take 2 arrays (thus, binary ufuncs) \n",
    "and return a single array as the result\n",
    "\"\"\"\n",
    "# Define two random arrays\n",
    "x = np.random.randn(5)\n",
    "y = np.random.randn(5)\n",
    "print(\"x = {}\".format(x))\n",
    "print(\"y = {}\".format(y))\n",
    "print(\"Element-wise maximum between x's and y's elements: {}\".format(np.maximum(x, y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Universal Unary Functions (1 of 2)\n",
    "\n",
    "<center>![](./img/np_unary_ufuncs_1.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Universal Unary Functions (2 of 2)\n",
    "\n",
    "<center>![](./img/np_unary_ufuncs_2.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Universal Binary Functions\n",
    "\n",
    "<center>![](./img/np_binary_ufuncs.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mathematical and Statistical Methods\n",
    "\n",
    "-  A set of mathematical functions which compute statistics about an entire array or about the data along an axis are accessible as array methods. \n",
    "\n",
    "-  Aggregations (often called reductions) like <code>**sum**</code>, <code>**mean**</code>, and <code>**std**</code> (standard deviation) can be invoked:\n",
    "    -  by calling the array instance method;\n",
    "    -  using the top level <code>**numpy**</code> function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original matrix is:\n",
      "[[ 0.80315271  0.43595353  0.25475635 -1.41916843]\n",
      " [ 0.08995756  0.24721462  2.36291207  0.36666885]\n",
      " [ 0.24413369 -0.2324963   0.709209    0.05656641]\n",
      " [-1.49674819  0.25793226 -1.04658819  0.23984137]\n",
      " [-1.52227821  0.13571985  0.81259401  0.86914029]]\n",
      "The mean of the matrix is: 0.1084236629677177\n",
      "The mean of the matrix is: 0.1084236629677177\n",
      "The mean of the matrix along the columns is: [ 0.01867354  0.76668828  0.1943532  -0.51139069  0.07379399]\n",
      "The sum of the matrix along the rows is: [-1.88178244  0.84432396  3.09288324  0.1130485 ]\n"
     ]
    }
   ],
   "source": [
    "# Consider the following normally-distributed random 5x4 matrix data\n",
    "matrix = np.random.randn(5, 4)\n",
    "print(\"The original matrix is:\\n{}\".format(matrix))\n",
    "print(\"The mean of the matrix is: {}\".format(matrix.mean()))\n",
    "print(\"The mean of the matrix is: {}\".format(np.mean(matrix)))\n",
    "\"\"\"\n",
    "Functions like 'mean' and 'sum' take an optional axis argument, \n",
    "which computes the statistic over the given axis,\n",
    "resulting in an array with one fewer dimension\n",
    "\"\"\"\n",
    "print(\"The mean of the matrix along the columns is: {}\".format(matrix.mean(axis=1)))\n",
    "print(\"The sum of the matrix along the rows is: {}\".format(matrix.sum(axis=0)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Table of <code>numpy</code> Statistical Methods\n",
    "\n",
    "<center>![](./img/np_stat_funcs.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Table of <code>numpy</code> Set Methods\n",
    "\n",
    "<center>![](./img/np_set_funcs.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## I/O with <code>numpy</code> Arrays\n",
    "\n",
    "-  <code>**numpy**</code> is able to **save** and **load** data to and from disk either in **_text_** or **_binary_** format. \n",
    "\n",
    "-  We only discuss built-in binary format, since we will use <code>**pandas**</code> for loading text or tabular data.\n",
    "\n",
    "-  <code>**np.save**</code> and <code>**np.load**</code> are the two workhorse functions for efficiently saving and loading array data on disk. \n",
    "\n",
    "-  Arrays are saved by default in an **_uncompressed raw binary_** format with file extension <code>**.npy**</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original array is: [-0.00948631 -0.18875794 -0.49668335 -0.08650266  1.06290762]\n",
      "The array loaded from disk is: [-0.00948631 -0.18875794 -0.49668335 -0.08650266  1.06290762]\n"
     ]
    }
   ],
   "source": [
    "# Consider the following numpy array\n",
    "arr = np.random.randn(5)\n",
    "print(\"The original array is: {}\".format(arr))\n",
    "# Persist the above array out to disk to the specified path on disk\n",
    "np.save(\"./data/np_array\", arr) # if no '.npy' extension is specified it will be appended\n",
    "# Load the array back from the specified path on disk\n",
    "arr_loaded = np.load(\"./data/np_array.npy\")\n",
    "print(\"The array loaded from disk is: {}\".format(arr_loaded))\n",
    "\n",
    "# NOTE: If you need to save multiple arrays in a zip archive \n",
    "# use 'np.savez' and pass the arrays as keyword arguments:\n",
    "#    np.savez(\"path/to/arr_archive.npz\", a=arr_a, b=arr_b)\n",
    "# When this is loaded back with: \n",
    "#    arr_archive = np.load(\"./data/np_array.npy\")\n",
    "# You get back a dict-like object which loads the individual arrays lazily:\n",
    "#    arr_archive['b'] # refers to the second array in the archive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Table of <code>numpy</code> Linear Algebra Functions\n",
    "\n",
    "<center>![](./img/np_lin_alg_funcs.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Table of <code>numpy.random</code> Functions\n",
    "\n",
    "<center>![](./img/np_random_funcs.png)</center>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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
}