04_scipython/04_scipython_notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "STAT 479: Machine Learning (Fall 2018)  \n",
    "Instructor: Sebastian Raschka (sraschka@wisc.edu)  \n",
    "Course website: http://pages.stat.wisc.edu/~sraschka/teaching/stat479-fs2018/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# L04: Scientific Computing in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext watermark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "format": "row",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sebastian Raschka \n",
      "\n",
      "CPython 3.6.6\n",
      "IPython 6.5.0\n",
      "\n",
      "numpy 1.15.1\n",
      "scipy 1.1.0\n",
      "matplotlib 2.2.3\n"
     ]
    }
   ],
   "source": [
    "%watermark -v -a 'Sebastian Raschka' -p numpy,scipy,matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy -- Working with Numerical Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction to NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section offers a quick tour of the NumPy library for working with multi-dimensional arrays in Python. NumPy (short for Numerical Python) was created by Travis Oliphant in 2005, by merging Numarray into Numeric. Since then, the open source NumPy library has evolved into an essential library for scientific computing in Python and has become a building block of many other scientific libraries, such as SciPy, Scikit-learn, Pandas, and others.\n",
    "What makes NumPy so particularly attractive to the scientific community is that it provides a convenient Python interface for working with multi-dimensional array data structures efficiently; the NumPy array data structure is also called `ndarray`, which is short for *n*-dimensional array. \n",
    "\n",
    "In addition to being mostly implemented in C and using Python as a \"glue language,\" the main reason why NumPy is so efficient for numerical computations is that NumPy arrays use contiguous blocks of memory that can be efficiently cached by the CPU. In contrast, Python lists are arrays of pointers to objects in random locations in memory, which cannot be easily cached and come with a more expensive memory-look-up. However, the computational efficiency and low-memory footprint come at a cost: NumPy arrays have a fixed size and are homogeneous, which means that all elements must have the same type. Homogenous `ndarray` objects have the advantage that NumPy can carry out operations using efficient C loops and avoid expensive type checks and other overheads of the Python API. While adding and removing elements from the end of a Python list is very efficient, altering the size of a NumPy array is very expensive since it requires to create a new array and carry over the contents of the old array that we want to expand or shrink. \n",
    "\n",
    "Besides being more efficient for numerical computations than native Python code, NumPy can also be more elegant and readable due to vectorized operations and broadcasting, which are features that we will explore in this lecture. While this material should be sufficient to follow the code examples in this course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### N-dimensional Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy is built around [`ndarrays`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html) objects, which are high-performance multi-dimensional array data structures. Intuitively, we can think of a one-dimensional NumPy array as a data structure to represent a vector of elements -- you may think of it as a fixed-size Python list where all elements share the same type. Similarly, we can think of a two-dimensional array as a data structure to represent a matrix or a Python list of lists. While NumPy arrays can have up to 32 dimensions if it was compiled without alterations to the source code, we will focus on lower-dimensional arrays for the purpose of illustration in this introduction.\n",
    "\n",
    "Now, let us get started with NumPy by calling the `array` function to create a two-dimensional NumPy array, consisting of two rows and three columns, from a list of lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "lst = [[1, 2, 3], [4, 5, 6]]\n",
    "ary2d = np.array(lst)\n",
    "ary2d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/numpy-intro/array_1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, NumPy infers the type of the array upon construction. Since we passed Python integers to the array, the `ndarray` object `ary2d` should be of type `int64` on a 64-bit machine, which we can confirm by accessing the `dtype` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary2d.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to construct NumPy arrays of different types, we can pass an argument to the `dtype` parameter of the `array` function, for example `np.int32` to create 32-bit arrays. For a full list of supported data types, please refer to the official [NumPy documentation](https://docs.scipy.org/doc/numpy/user/basics.types.html). Once an array has been constructed, we can downcast or recast its type via the `astype` method as shown in the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [4., 5., 6.]], dtype=float32)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float32_ary = ary2d.astype(np.float32)\n",
    "float32_ary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float32')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float32_ary.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code snippet above returned `8`, which means that each element in the array (remember that `ndarray`s are homogeneous) takes up 8 bytes in memory. This result makes sense since the array `ary2d` has type `int64` (64-bit integer), which we determined earlier, and 8 bits equals 1 byte. (Note that `'int64'` is just a shorthand for `np.int64`.)\n",
    "\n",
    "To return the number of elements in an array, we can use the `size` attribute, as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary2d.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the number of dimensions of our array (Intuitively, you may think of *dimensions* as the *rank* of a tensor) can be obtained via the `ndim` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary2d.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we are interested in the number of elements along each array dimension (in the context of NumPy arrays, we may also refer to them as *axes*), we can access the `shape` attribute as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary2d.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `shape` is always a tuple; in the code example above, the two-dimensional `ary` object has two *rows* and *three* columns, `(2, 3)`, if we think of it as a matrix representation.\n",
    "\n",
    "Similarly, the `shape` of the one-dimensional array only contains a single value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 3]).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Construction Routines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section provides a non-comprehensive list of array construction functions. Simple yet useful functions exist to construct arrays containing ones or zeros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating arrays of ones or zeros can also be useful as placeholder arrays, in cases where we do not want to use the initial values for computations but want to fill it with other values right away. If we do not need the initial values (for instance, `'0.'` or `'1.'`), there is also `numpy.empty`, which follows the same syntax as `numpy.ones` and `np.zeros`. However, instead of filling the array with a particular value, the `empty` function creates the array with non-sensical values from memory. We can think of `zeros` as a function that creates the array via `empty` and then sets all its values to `0.` -- in practice, a difference in speed is not noticeable, though.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy also comes with functions to create identity matrices and diagonal matrices as `ndarrays` that can be useful in the context of linear algebra -- a topic that we will explore later in this section. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 0, 0],\n",
       "       [0, 3, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag((3, 3, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, I want to mention two very useful functions for creating sequences of numbers within a specified range, namely, `arange` and `linspace`. NumPy's `arange` function follows the same syntax as Python's `range` objects: If two arguments are provided, the first argument represents the start value and the second value defines the stop value of a half-open interval:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(4., 10.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that `arange` also performs type inference similar to the `array` function. If we only provide a single function argument, the range object treats this number as the endpoint of the interval and starts at 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to Python's `range`, a third argument can be provided to define the *step* (the default step size is 1). For example, we can obtain an array of all uneven values between one and ten as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 3., 5., 7., 9.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1., 11., 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `linspace` function is especially useful if we want to create a particular number of evenly spaced values in a specified half-open interval:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0., 1., num=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we will go over the basics of retrieving NumPy array elements via different indexing methods. Simple NumPy indexing and slicing works similar to Python lists, which we will demonstrate in the following code snippet, where we retrieve the first element of a one-dimensional array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([1, 2, 3])\n",
    "ary[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, the same Python semantics apply to slicing operations. The following example shows how to fetch the first two elements in `ary`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[:2] # equivalent to ary[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we work with arrays that have more than one dimension or axis, we separate our indexing or slicing operations by commas as shown in the series of examples below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3],\n",
    "                [4, 5, 6]])\n",
    "\n",
    "ary[0, 0] # upper left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[-1, -1] # lower right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[0, 1] # first row, second column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/numpy-intro/array_2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[0] # entire first row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[:, 0] # entire first column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[:, :2] # first two columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[0, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Math and Universal Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous sections, you learned how to create NumPy arrays and how to access different elements in an array. It is about time that we introduce one of the core features of NumPy that makes working with `ndarray` so efficient and convenient: vectorization. While we typically use for-loops if we want to perform arithmetic operations on sequence-like objects, NumPy provides vectorized wrappers for performing element-wise operations implicitly via so-called *ufuncs* -- short for universal functions.\n",
    "\n",
    "As of this writing, there are more than 60 ufuncs available in NumPy; ufuncs are implemented in compiled C code and very fast and efficient compared to vanilla Python. In this section, we will take a look at the most commonly used ufuncs, and I recommend you to check out the [official documentation](https://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs) for a complete list.\n",
    "\n",
    "To provide an example of a simple ufunc for element-wise addition, consider the following example, where we add a scalar (here: 1) to each element in a nested Python list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 3, 4], [5, 6, 7]]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [[1, 2, 3], [4, 5, 6]]\n",
    "\n",
    "for row_idx, row_val in enumerate(lst):\n",
    "    for col_idx, col_val in enumerate(row_val):\n",
    "        lst[row_idx][col_idx] += 1\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This for-loop approach is very verbose, and we could achieve the same goal more elegantly using list comprehensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 3, 4], [5, 6, 7]]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [[1, 2, 3], [4, 5, 6]]\n",
    "[[cell + 1 for cell in row] for row in lst]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can accomplish the same using NumPy's ufunc for element-wise scalar addition as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3, 4],\n",
       "       [5, 6, 7]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "ary = np.add(ary, 1)\n",
    "ary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ufuncs for basic arithmetic operations are `add`, `subtract`, `divide`, `multiply`, and `exp` (exponential). However, NumPy uses operator overloading so that we can use mathematical operators (`+`, `-`, `/`, `*`, and `**`) directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  9, 16],\n",
       "       [25, 36, 49]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, we have seen examples of *binary* ufuncs, which are ufuncs that take two arguments as an input. In addition, NumPy implements several useful *unary* ufuncs, such as `log` (natural logarithm), `log10` (base-10 logarithm), and `sqrt` (square root).\n",
    "\n",
    "Often, we want to compute the sum or product of array element along a given axis. For this purpose, we can use a ufunc's `reduce` operation. By default, `reduce` applies an operation along the first axis (`axis=0`). In the case of a two-dimensional array, we can think of the first axis as the rows of a matrix. Thus, adding up elements along rows yields the column sums of that matrix as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 7, 9])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3], \n",
    "                [4, 5, 6]])\n",
    "\n",
    "np.add.reduce(ary) # column sumns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To compute the row sums of the array above, we can specify `axis=1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6, 15])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add.reduce(ary, axis=1) # row sums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While it can be more intuitive to use `reduce` as a more general operation, NumPy also provides shorthands for specific operations such as `product` and `sum`. For example, `sum(axis=0)` is equivalent to `add.reduce`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 7, 9])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary.sum(axis=0) # column sums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/numpy-intro/ufunc.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a word of caution, keep in mind that `product` and `sum` both compute the product or sum of the entire array if we do not specify an axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other useful unary ufuncs are:\n",
    "    \n",
    "- mean (computes arithmetic average)\n",
    "- std (computes the standard deviation)\n",
    "- var (computes variance)\n",
    "- np.sort (sorts an array)\n",
    "- np.argsort (returns indices that would sort an array)\n",
    "- np.min (returns the minimum value of an array)\n",
    "- np.max (returns the maximum value of an array)\n",
    "- np.argmin (returns the index of the minimum value)\n",
    "- np.argmax (returns the index of the maximum value)\n",
    "- array_equal (checks if two arrays have the same shape and elements)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A topic we glanced over in the previous section is broadcasting. Broadcasting allows us to perform vectorized operations between two arrays even if their dimensions do not match by creating implicit multidimensional grids. You already learned about ufuncs in the previous section where we performed element-wise addition between a scalar and a multidimensional array, which is just one example of broadcasting. \n",
    "\n",
    "\n",
    "![](images/numpy-intro/broadcasting-1.png)\n",
    "\n",
    "Naturally, we can also perform element-wise operations between arrays of equal dimensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 7, 9])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary1 = np.array([1, 2, 3])\n",
    "ary2 = np.array([4, 5, 6])\n",
    "\n",
    "ary1 + ary2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In contrast to what we are used from linear algebra, we can also add arrays of different shapes. In the example above, we will add a one-dimensional to a two-dimensional array, where NumPy creates an implicit multidimensional grid from the one-dimensional array `ary1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  7,  9],\n",
       "       [ 8, 10, 12]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary3 = np.array([[4, 5, 6], \n",
    "                 [7, 8, 9]])\n",
    "\n",
    "ary3 + ary1 # similarly, ary1 + ary3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/numpy-intro/broadcasting-2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advanced Indexing -- Memory Views and Copies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous sections, we have used basic indexing and slicing routines. It is important to note that basic integer-based indexing and slicing create so-called *views* of NumPy arrays in memory. Working with views can be highly desirable since it avoids making unnecessary copies of arrays to save memory resources. To illustrate the concept of memory views, let us walk through a simple example where we access the first row in an array, assign it to a variable, and modify that variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[100, 101, 102],\n",
       "       [  4,   5,   6]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3],\n",
    "                [4, 5, 6]])\n",
    "\n",
    "first_row = ary[0]\n",
    "first_row += 99\n",
    "ary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see in the example above, changing the value of `first_row` also affected the original array. The reason for this is that `ary[0]` created a view of the first row in `ary`, and its elements were then incremented by 99. The same concept applies to slicing operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[100, 101, 102],\n",
       "       [  4,   5,   6]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3],\n",
    "                [4, 5, 6]])\n",
    "\n",
    "first_row = ary[:1]\n",
    "first_row += 99\n",
    "ary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1, 101,   3],\n",
       "       [  4, 104,   6]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3],\n",
    "                [4, 5, 6]])\n",
    "\n",
    "center_col = ary[:, 1]\n",
    "center_col += 99\n",
    "ary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we are working with NumPy arrays, it is always important to be aware that **slicing creates views** -- sometimes it is desirable since it can speed up our code by avoiding to create unnecessary copies in memory. However, in certain scenarios we want force a copy of an array; we can do this via the `copy` method as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3],\n",
    "                [4, 5, 6]])\n",
    "\n",
    "second_row = ary[1].copy()\n",
    "second_row += 99\n",
    "ary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to basic single-integer indexing and slicing operations, NumPy supports advanced indexing routines called *fancy* indexing. Via fancy indexing, we can use tuple or list objects of non-contiguous integer indices to return desired array elements. Since fancy indexing can be performed with non-contiguous sequences, it cannot return a view -- a contiguous slice from memory. Thus, fancy indexing always returns a copy of an array -- it is important to keep that in mind. The following code snippets show some fancy indexing examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [4, 6]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3],\n",
    "                [4, 5, 6]])\n",
    "\n",
    "ary[:, [0, 2]] # first and and last column"
   ]
  },
  {
   "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": [
    "this_is_a_copy = ary[:, [0, 2]]\n",
    "this_is_a_copy += 99\n",
    "ary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 1],\n",
       "       [6, 4]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[:, [2, 0]] # first and and last column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Finally, we can also use Boolean masks for indexing -- that is, arrays of `True` and `False` values. Consider the following example, where we return all values in the array that are greater than 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3],\n",
    "                [4, 5, 6]])\n",
    "\n",
    "greater3_mask = ary > 3\n",
    "greater3_mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using these masks, we can select elements given our desired criteria:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[greater3_mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also chain different selection criteria using the logical *and* operator '&' or the logical *or* operator '|'. The example below demonstrates how we can select array elements that are greater than 3 and divisible by 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 6])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[(ary > 3) & (ary % 2 == 0)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that indexing using Boolean arrays is also considered \"fancy indexing\" and thus returns a copy of the array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Number Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In machine learning and deep learning, we often have to generate arrays of random numbers -- for example, the initial values of our model parameters before optimization. NumPy has a `random` subpackage to create random numbers and samples from a variety of distributions conveniently. Again, I encourage you to browse through the more comprehensive [numpy.random documentation](https://docs.scipy.org/doc/numpy/reference/routines.random.html) for a more comprehensive list of functions for random sampling.\n",
    "\n",
    "To provide a brief overview of the pseudo-random number generators that we will use most commonly, let's start with drawing a random sample from a uniform distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.69646919, 0.28613933, 0.22685145])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(123)\n",
    "np.random.rand(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code snippet above, we first seeded NumPy's random number generator. Then, we drew three random samples from a uniform distribution via `random.rand` in the half-open interval [0, 1). I highly recommend the seeding step in practical applications as well as in research projects, since it ensures that our results are reproducible. If we run our code sequentially -- for example, if we execute a Python script -- it should be sufficient to seed the random number generator only once at the beginning to enforce reproducible outcomes between different runs. However, it is often useful to create separate `RandomState` objects for various parts of our code, so that we can test methods of functions reliably in unit tests. Working with multiple, separate `RandomState` objects can also be useful if we run our code in non-sequential order -- for example if we are experimenting with our code in interactive sessions or Jupyter Notebook environments. \n",
    "\n",
    "The example below shows how we can use a `RandomState` object to create the same results that we obtained via np.random.rand in the previous code snippet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.69646919, 0.28613933, 0.22685145])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng1 = np.random.RandomState(seed=123)\n",
    "rng1.rand(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshaping Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In practice, we often run into situations where existing arrays do not have the *right* shape to perform certain computations. As you might remember from the beginning of this lecture, the size of NumPy arrays is fixed. Fortunately, this does not mean that we have to create new arrays and copy values from the old array to the new one if we want arrays of different shapes -- the size is fixed, but the shape is not. NumPy provides a `reshape` methods that allow us to obtain a view of an array with a different shape. \n",
    "\n",
    "For example, we can reshape a one-dimensional array into a two-dimensional one using `reshape` as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary1d = np.array([1, 2, 3, 4, 5, 6])\n",
    "ary2d_view = ary1d.reshape(2, 3)\n",
    "ary2d_view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.may_share_memory(ary2d_view, ary1d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While we need to specify the desired elements along each axis, we need to make sure that the reshaped array has the same number of elements as the original one. However, we do not need to specify the number elements in each axis; NumPy is smart enough to figure out how many elements to put along an axis if only one axis is unspecified (by using the placeholder `-1`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary1d.reshape(2, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary1d.reshape(-1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can, of course, also use `reshape` to flatten an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[[1, 2, 3],\n",
    "                [4, 5, 6]]])\n",
    "\n",
    "ary.reshape(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, we are interested in merging different arrays. Unfortunately, there is no efficient way to do this without creating a new array, since NumPy arrays have a fixed size. While combining arrays should be avoided if possible -- for reasons of computational efficiency -- it is sometimes necessary. To combine two or more array objects, we can use NumPy's `concatenate` function as shown in the following examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 1, 2, 3])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([1, 2, 3])\n",
    "\n",
    "# stack along the first axis\n",
    "np.concatenate((ary, ary)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [1, 2, 3]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([[1, 2, 3]])\n",
    "\n",
    "# stack along the first axis (here: rows)\n",
    "np.concatenate((ary, ary), axis=0) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 1, 2, 3]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# stack along the second axis (here: column)\n",
    "np.concatenate((ary, ary), axis=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison Operators and Masks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous section, we already briefly introduced the concept of Boolean masks in NumPy. Boolean masks are `bool`-type arrays (storing `True` and `False` values) that have the same shape as a certain target array. For example, consider the following 4-element array below. Using comparison operators (such as `<`, `>`, `<=`, and `>=`), we can create a Boolean mask of that array which consists of `True` and `False` elements depending on whether a condition is met in the target array (here: `ary`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True,  True])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([1, 2, 3, 4])\n",
    "mask = ary > 2\n",
    "mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One we created such a Boolean mask, we can use it to select certain entries from the target array -- those entries that match the condition upon which the mask was created):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beyond the selection of elements from an array, Boolean masks can also come in handy when we want to count how many elements in an array meet a certain condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True,  True])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A related, useful function to assign values to specific elements in an array is the `np.where` function. In the example below, we assign a 1 to all values in the array that are greater than 2 -- and 0, otherwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1, 1])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(ary > 2, 1, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also so-called bit-wise operators that we can use to specify more complex selection criteria:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1, 1])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([1, 2, 3, 4])\n",
    "mask = ary > 2\n",
    "ary[mask] = 1\n",
    "ary[~mask] = 0\n",
    "ary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `~` operator in the example above is one of the logical operators in NumPy:\n",
    "    \n",
    "- A: `&`  or `np.bitwise_and`\n",
    "- Or: `|` or `np.bitwise_or`\n",
    "- Xor: `^` or `np.bitwise_xor`\n",
    "- Not: `~` or `np.bitwise_not`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These logical operators allow us to chain an arbitrary number of conditions to create even more \"complex\" Boolean masks. For example, using the \"Or\" operator, we can select all elements that are greater than 3 or smaller than 2 as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False,  True])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ary = np.array([1, 2, 3, 4])\n",
    "\n",
    "(ary > 3) | (ary < 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And, for example, to negate the condition, we can use the `~` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True, False])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "~((ary > 3) | (ary < 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linear Algebra with NumPy Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Intuitively, we can think of one-dimensional NumPy arrays as data structures that represent row vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_vector = np.array([1, 2, 3])\n",
    "row_vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can use two-dimensional arrays to create column vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "column_vector = np.array([[1, 2, 3]]).reshape(-1, 1)\n",
    "column_vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of reshaping a one-dimensional array into a two-dimensional one, we can simply add a new axis as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_vector[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in this context, `np.newaxis` behaves like `None`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_vector[:, None]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All three approaches listed above, using `reshape(-1, 1)`, `np.newaxis`, or `None` yield the same results -- all three approaches create views not copies of the `row_vector` array.\n",
    "\n",
    "As we remember from the Linear Algebra appendix, we can think of a column vector as a matrix consisting only of one column. To perform matrix multiplication between matrices, we learned that number of columns of the left matrix must match the number of rows of the matrix to the right. In NumPy, we can perform matrix multiplication via the `matmul` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix = np.array([[1, 2, 3], \n",
    "                   [4, 5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14],\n",
       "       [32]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(matrix, column_vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/numpy-intro/matmul.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if we are working with matrices and vectors, NumPy can be quite forgiving if the dimensions of matrices and one-dimensional arrays do not match exactly -- thanks to broadcasting. The following example yields the same result as the matrix-column vector multiplication, except that it returns a one-dimensional array instead of a two-dimensional one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([14, 32])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(matrix, row_vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can compute the dot-product between two vectors (here: the vector norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(row_vector, row_vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy has a special `dot` function that behaves similar to `matmul` on pairs of one- or two-dimensional arrays -- its underlying implementation is different though, and one or the other can be slightly faster on specific machines and versions of [BLAS](https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(row_vector, row_vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([14, 32])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(matrix, row_vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14],\n",
       "       [32]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(matrix, column_vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to the examples above we can use `matmul` or `dot` to multiply two matrices (here: two-dimensional arrays). In this context, NumPy arrays have a handy `transpose` method to transpose matrices if necessary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix = np.array([[1, 2, 3], \n",
    "                   [4, 5, 6]])\n",
    "\n",
    "matrix.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/numpy-intro/transpose.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14, 32],\n",
       "       [32, 77]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(matrix, matrix.transpose())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/numpy-intro/matmatmul.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While `transpose` can be annoyingly verbose for implementing linear algebra operations -- think of [PEP8's](https://www.python.org/dev/peps/pep-0008/) *80 character per line* recommendation -- NumPy has a shorthand for that: `T`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this section demonstrates some of the basic linear algebra operations carried out on NumPy arrays that we use in practice, you can find an additional function in the documentation of NumPy's submodule for linear algebra: [`numpy.linalg`](https://docs.scipy.org/doc/numpy/reference/routines.linalg.html). If you want to perform a particular linear algebra routine that is not implemented in NumPy, it is also worth consulting the [`scipy.linalg` documentation](https://docs.scipy.org/doc/scipy/reference/linalg.html) -- SciPy is a library for scientific computing built on top of NumPy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "I want to mention that there is also a special [`matrix`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.matrix.html) type in NumPy. NumPy `matrix` objects are analogous to NumPy arrays but are restricted to two dimensions. Also, matrices define certain operations differently than arrays; for instance, the `*` operator performs matrix multiplication instead of element-wise multiplication. However, NumPy `matrix` is less popular in the science community compared to the more general array data structure. \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SciPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SciPy is another open-source library from Python's scientific computing stack. SciPy includes submodules for integration, optimization, and many other kinds of computations that are out of the scope of NumPy itself. We will not cover SciPy as a library here, since it can be more considered as an \"add-on\" library on top of NumPy. Rather, we may discuss individual SciPy function in the context of homework exercises if the need arises.\n",
    "\n",
    "In any case, I recommend you to take a look at the SciPy documentation to get a brief overview of the different function that exists within this library: [https://docs.scipy.org/doc/scipy/reference/](https://docs.scipy.org/doc/scipy/reference/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, we will briefly cover Matplotlib in this lecture. Matplotlib is a plotting library for Python created by John D. Hunter in 2003. Unfortunately, John D. Hunter became ill and past away in 2012. However, Matplot is still the most mature plotting library, and is being maintained until this day (in fact, version 3.0 was just released a few weeks ago, in summer 2018).\n",
    "\n",
    "In general, Matplotlib is a rather \"low-level\" plotting library, which means that it has a lot of room for customization. The advantage of Matplotlib is that it is so customizable; the disadvantage of Matplotlib is that it is so customizable -- some people find it a little bit too verbose due to all the different options.\n",
    "\n",
    "In any case, Matplotlib is among the most widely used plotting library and the go-to choice for many data scientists and machine learning researchers and practictioners.\n",
    "\n",
    "In my opinion, the best way to work with Matplotlib is to use the Matplotlib gallery on the official website at [https://matplotlib.org/gallery/index.html](https://matplotlib.org/gallery/index.html) often. It contains code examples for creating various different kinds of plots, which are useful as templates for creating your own plots. Also, if you are completely new to Matplotlib, I recommend the tutorials at [https://matplotlib.org/tutorials/index.html](https://matplotlib.org/tutorials/index.html).\n",
    "\n",
    "In this section, we will look at a few very simple examples, which should be very intuitive and shouldn't require much explanation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main plotting functions of Matplotlib are contained in the pyplot module, which we imported above. Note that the `%matplotlib inline` command is an \"IPython magic\" command -- we discussed this last lecture. This particular `%matplotlib inline` is specific to Jupyter notebooks (which, in our case, use an IPython kernel) to show the plots \"inline,\" that is, the notebook itself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting Functions and Lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 100)\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add axis ranges and labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 100)\n",
    "plt.plot(x, np.sin(x))\n",
    "\n",
    "plt.xlim([2, 8])\n",
    "plt.ylim([0, 0.75])\n",
    "\n",
    "plt.xlabel('x-axis')\n",
    "plt.ylabel('y-axis')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 100)\n",
    "\n",
    "plt.plot(x, np.sin(x), label=('sin(x)'))\n",
    "plt.plot(x, np.cos(x), label=('cos(x)'))\n",
    "\n",
    "plt.ylabel('f(x)')\n",
    "plt.xlabel('x')\n",
    "\n",
    "plt.legend(loc='lower left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scatter Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "rng = np.random.RandomState(123)\n",
    "x = rng.normal(size=500)\n",
    "y = rng.normal(size=500)\n",
    "\n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bar Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# input data\n",
    "means = [1, 2, 3]\n",
    "stddevs = [0.2, 0.4, 0.5]\n",
    "bar_labels = ['bar 1', 'bar 2', 'bar 3']\n",
    "\n",
    "\n",
    "# plot bars\n",
    "x_pos = list(range(len(bar_labels)))\n",
    "plt.bar(x_pos, means, yerr=stddevs)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAD6BJREFUeJzt3X+s3Xddx/Hny5WB/HIbu5t1m97OVGQx0c0bMkWIYUS3FelQRkaMNLikMQEF0UhxifBnpwJCQjCVTYqZMByQLYACVpD4B9XbMfaDgu1GGWWlvchPxQwW3v5xvhcP5f7q+Z57zu2nz0dyc873c77nfN/5nG9f/dzvj89NVSFJatePTLsASdL6MuglqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9Jjds07QIAzj///JqdnZ12GZJ0Wjlw4MBXqmpmtfU2RNDPzs4yPz8/7TIk6bSS5AtrWc9DN5LUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1LgNcWestJHM7vrgsq8d2b1tgpVI4+GIXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNc1Iz6RSsNOEZOOmZNiZH9JLUuFWDPsmtSU4kuX+o7bwkH01yqHs8t2tPkrckOZzk3iRXrGfxkqTVrWVE/w7g6pPadgH7qmorsK9bBrgG2Nr97ATeNp4yJUmjWjXoq+oTwFdPat4O7O2e7wWuG2p/Zw18EjgnyeZxFStJOnWjHqO/sKqOAXSPF3TtFwFfHFrvaNcmSZqScZ+MzRJtteSKyc4k80nmFxYWxlyGJGnRqEF/fPGQTPd4oms/ClwytN7FwCNLfUBV7amquaqam5mZGbEMSdJqRg36u4Ad3fMdwJ1D7S/trr65EvjG4iEeSdJ0rHrDVJJ3Ab8KnJ/kKPA6YDfwniQ3Ag8D13erfwi4FjgMfBt42TrULEk6BasGfVW9ZJmXrlpi3QJe3rcoSdL4OAWCzjirTWMgtcYpECSpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuM2TbsAqSWzuz644utHdm+bUCXS/3NEL0mNM+glqXEGvSQ1zqCXpMZ5MlbNWe2EqHSm6TWiT/KHSR5Icn+SdyV5QpItSfYnOZTk9iRnj6tYSdKpGznok1wE/AEwV1U/B5wF3ADcDLypqrYCXwNuHEehkqTR9D1Gvwn40SSbgCcCx4DnAnd0r+8Fruu5DUlSDyMHfVV9CfhL4GEGAf8N4ADw9ap6rFvtKHDRUu9PsjPJfJL5hYWFUcuQJK2iz6Gbc4HtwBbgJ4AnAdcssWot9f6q2lNVc1U1NzMzM2oZkqRV9Dl08zzg81W1UFXfBd4H/DJwTncoB+Bi4JGeNUqSeugT9A8DVyZ5YpIAVwGfAT4GvKhbZwdwZ78SJUl99DlGv5/BSde7gfu6z9oDvAZ4dZLDwNOAW8ZQpyRpRL1umKqq1wGvO6n5IeCZfT5XkjQ+ToEgSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS43rNRy9pvGZ3fXDF14/s3jahStQSR/SS1DhH9NIErTZil9aDI3pJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjesV9EnOSXJHks8mOZjkl5Kcl+SjSQ51j+eOq1hJ0qnrO6J/M/BPVfWzwM8DB4FdwL6q2grs65YlSVMyctAneSrwHOAWgKr6TlV9HdgO7O1W2wtc17dISdLo+ozoLwUWgL9N8qkkb0/yJODCqjoG0D1eMIY6JUkj6hP0m4ArgLdV1eXA/3AKh2mS7Ewyn2R+YWGhRxmSpJX0CfqjwNGq2t8t38Eg+I8n2QzQPZ5Y6s1Vtaeq5qpqbmZmpkcZkqSVjBz0VfVl4ItJnt41XQV8BrgL2NG17QDu7FWhJKmXvn9h6veB25KcDTwEvIzBfx7vSXIj8DBwfc9tSJJ66BX0VXUPMLfES1f1+VxpJf45PunUeGesJDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJalzf6+ilsfPySWm8HNFLUuMc0UunkZV+2zmye9sEK9HpxBG9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqc0xRrKvzjItLkOKKXpMYZ9JLUOINekhpn0EtS4wx6SWpc76BPclaSTyX5QLe8Jcn+JIeS3J7k7P5lSpJGNY4R/SuBg0PLNwNvqqqtwNeAG8ewDUnSiHoFfZKLgW3A27vlAM8F7uhW2Qtc12cbkqR++o7o/wr4E+B73fLTgK9X1WPd8lHgoqXemGRnkvkk8wsLCz3LkCQtZ+SgT/J84ERVHRhuXmLVWur9VbWnquaqam5mZmbUMiRJq+gzBcKzgBckuRZ4AvBUBiP8c5Js6kb1FwOP9C9TkjSqkUf0VfXaqrq4qmaBG4B/qarfBj4GvKhbbQdwZ+8qJUkjW4/r6F8DvDrJYQbH7G9Zh21IktZoLLNXVtXHgY93zx8CnjmOz5Uk9eedsZLUOINekhrnHx6RGrHaH3M5snvbhCrRRuOIXpIaZ9BLUuMMeklqnEEvSY0z6CWpcV51I50hvCrnzOWIXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNc1IzrYvVJtCSNDmO6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjRr68MsklwDuBHwe+B+ypqjcnOQ+4HZgFjgAvrqqv9S9VG4mXT0qnjz4j+seAP6qqZwBXAi9PchmwC9hXVVuBfd2yJGlKRg76qjpWVXd3z78FHAQuArYDe7vV9gLX9S1SkjS6sRyjTzILXA7sBy6sqmMw+M8AuGAc25AkjaZ30Cd5MvBe4FVV9c1TeN/OJPNJ5hcWFvqWIUlaRq+gT/I4BiF/W1W9r2s+nmRz9/pm4MRS762qPVU1V1VzMzMzfcqQJK2gz1U3AW4BDlbVG4deugvYAezuHu/sVaGkiVjtSqoju7dNqBKNW5/ZK58F/A5wX5J7urY/ZRDw70lyI/AwcH2/EiVJfYwc9FX1b0CWefmqUT9XkjRe3hkrSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJalyfO2PVMP+wiNQOR/SS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNc/bKM5SzU+pUrbbPHNm9bUKV6FQ5opekxhn0ktQ4g16SGmfQS1LjPBl7GvPkmDaSlfZH98XpckQvSY1LVY3/Q5OrgTcDZwFvr6rdK60/NzdX8/PzY6/jdOclkNKAvxEsLcmBqppbbb2xj+iTnAW8FbgGuAx4SZLLxr0dSdLarMcx+mcCh6vqIYAk7wa2A59Zh21J0qrO9PMH63GM/iLgi0PLR7s2SdIUrMeIPku0/dCJgCQ7gZ3d4n8n+dyI2zsf+MqI711v1jYaaxtNs7Xl5jFW8sOffTr320+t5UPWI+iPApcMLV8MPHLySlW1B9jTd2NJ5tdyMmIarG001jYaaxvNmVDbehy6+Q9ga5ItSc4GbgDuWoftSJLWYOwj+qp6LMkrgA8zuLzy1qp6YNzbkSStzbrcGVtVHwI+tB6fvYTeh3/WkbWNxtpGY22jab62dblhSpK0cTgFgiQ17rQK+iTXJ3kgyfeSzJ302muTHE7yuSS/PtR+ddd2OMmuCdV5e5J7up8jSe7p2meT/O/Qa389iXpOqu31Sb40VMO1Q68t2YcTrO0vknw2yb1J3p/knK596v3W1THxfWmFWi5J8rEkB7t/E6/s2pf9fidc35Ek93U1zHdt5yX5aJJD3eO5U6jr6UN9c0+SbyZ51bT6LcmtSU4kuX+obcl+ysBbuv3v3iRXrHlDVXXa/ADPAJ4OfByYG2q/DPg08HhgC/AggxPBZ3XPLwXO7ta5bMI1vwH4s+75LHD/lPvw9cAfL9G+ZB9OuLZfAzZ1z28Gbt5A/Tb1femkejYDV3TPnwL8Z/cdLvn9TqG+I8D5J7X9ObCre75r8fud8nf6ZQbXok+l34DnAFcM79/L9RNwLfCPDO5VuhLYv9btnFYj+qo6WFVL3Vi1HXh3VT1aVZ8HDjOYiuH70zFU1XeAxekYJiJJgBcD75rUNntYrg8npqo+UlWPdYufZHAPxkYx1X3pZFV1rKru7p5/CzjIxr8DfTuwt3u+F7huirUAXAU8WFVfmFYBVfUJ4KsnNS/XT9uBd9bAJ4Fzkmxey3ZOq6BfwXLTLkx7OoZnA8er6tBQ25Ykn0ryr0mePcFahr2i+9Xv1qFfn6fdVyf7XQajl0XT7reN1j/fl2QWuBzY3zUt9f1OWgEfSXIgg7vgAS6sqmMw+I8KuGBKtS26gR8chG2EfoPl+2nkfXDDBX2Sf05y/xI/K42elpt2YU3TMaxjnS/hB3ekY8BPVtXlwKuBv0/y1HHUcwq1vQ34aeAXunresPi2JT5q7JdkraXfktwEPAbc1jVNpN9WK32JtqlfspbkycB7gVdV1TdZ/vudtGdV1RUMZrF9eZLnTKmOJWVwM+cLgH/omjZKv61k5H1ww/2Fqap63ghvW2nahVWnYxjFanUm2QT8JvCLQ+95FHi0e34gyYPAzwBjnYx/rX2Y5G+AD3SLa5q6oq819NsO4PnAVdUdmJxUv61iIv1zKpI8jkHI31ZV7wOoquNDrw9/vxNVVY90jyeSvJ/Boa/jSTZX1bHukMOJadTWuQa4e7G/Nkq/dZbrp5H3wQ03oh/RXcANSR6fZAuwFfh3pjsdw/OAz1bV0cWGJDMZzNdPkku7Oh+aUD2LNQwf03shsHi2f7k+nGRtVwOvAV5QVd8eap96v7HBpvbozv/cAhysqjcOtS/3/U6yticlecricwYn2e9n0F87utV2AHdOurYhP/Db9kbotyHL9dNdwEu7q2+uBL6xeIhnVdM86z3CGeoXMvhf7VHgOPDhodduYnBVxOeAa4bar2VwRcKDwE0TrPUdwO+d1PZbwAMMrti4G/iNKfTh3wH3Afd2O87m1fpwgrUdZnAM8p7u5683Sr9Nc19appZfYfBr+71D/XXtSt/vBGu7tPuuPt19bzd17U8D9gGHusfzptR3TwT+C/ixobap9BuD/2yOAd/tsu3G5fqJwaGbt3b7330MXXm42o93xkpS41o5dCNJWoZBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4/4PFB0jftgN+RsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "rng = np.random.RandomState(123)\n",
    "x = rng.normal(0, 20, 1000) \n",
    "\n",
    "# fixed bin size\n",
    "bins = np.arange(-100, 100, 5) # fixed bin size\n",
    "\n",
    "plt.hist(x, bins=bins)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAEydJREFUeJzt3X+sZOV93/H3p2BbSuwUMBe0BbYL1mLFidqFXBEqFwuKnQBKjUlkF1Q5mwR1bQkk20klg5Fiq1Lk/DBGjRJhrcUKqDDGKaZGEWlMEDGKFBzv4vWyZMHsEozXbHdvcGRcYdEu/vaPOTcZbufeuTszd+bus++XNJozzzlnzpdnhs+e+8z5kapCktSufzbrAiRJa8ugl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXu5FkXAHD66afXpk2bZl2GJB1Xdu3a9fdVNTdsuXUR9Js2bWLnzp2zLkOSjitJvrOa5Ry6kaTGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcUODPsk5SR5Nsi/JU0k+0rWfluThJM92z6d27Unyh0n2J9mT5MK1/o+QJC1vNXv0R4HfqqqfBi4GbkjyDuAm4JGq2gw80r0GuBLY3D22AbdPvGpJ0qoNPTO2qg4Bh7rpHybZB5wFXA1c2i12F/CXwMe79rurd9fxx5OckmRD9z6SVvLop1eef9nN06lDTTmmMfokm4ALgK8DZy6Gd/d8RrfYWcB3+1Y72LVJkmZg1UGf5M3A/cBHq+rllRYd0FYD3m9bkp1Jdi4sLKy2DEnSMVpV0Cd5A72Qv6eqvtw1H06yoZu/ATjStR8Ezulb/WzgxaXvWVXbq2q+qubn5oZefE2SNKLVHHUT4A5gX1V9tm/Wg8DWbnor8JW+9l/tjr65GPiB4/OSNDuruUzxO4EPAk8m2d21fQL4XeBLSa4HXgDe3817CLgK2A+8Avz6RCuWJB2T1Rx181cMHncHuHzA8gXcMGZdkqQJ8cxYSWqcQS9JjTPoJalx6+KesdIJY9iZr9IacI9ekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcau5Z+yOJEeS7O1ruy/J7u7x/OItBpNsSvKjvnmfW8viJUnDreYyxXcCfwTcvdhQVf9hcTrJrcAP+pY/UFVbJlWgJGk8q7ln7GNJNg2alyTAB4B/N9myJEmTMu4Y/SXA4ap6tq/t3CTfTPK1JJcst2KSbUl2Jtm5sLAwZhmSpOWMG/TXAff2vT4EbKyqC4DfBL6Q5KcGrVhV26tqvqrm5+bmxixDkrSckYM+ycnALwP3LbZV1atV9VI3vQs4AJw/bpGSpNGNs0f/buDpqjq42JBkLslJ3fR5wGbgufFKlCSNYzWHV94L/DXw9iQHk1zfzbqW1w/bALwL2JPkW8B/Bz5cVd+fZMGSpGOzmqNurlum/dcGtN0P3D9+WZKkSfHMWElqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJatxqbjwiab149NMrz7/s5unUoeOKe/SS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcau5w9SOJEeS7O1r+1SS7yXZ3T2u6pt3c5L9SZ5J8otrVbgkaXVWcxz9ncAfAXcvab+tqj7T35DkHfRuMfgzwL8A/iLJ+VX12gRqlda/Yce5SzMwdI++qh4DVnvf16uBL1bVq1X1d8B+4KIx6pMkjWmcMfobk+zphnZO7drOAr7bt8zBrk2SNCOjBv3twNuALcAh4NauPQOWrUFvkGRbkp1Jdi4sLIxYhiRpmJGCvqoOV9VrVfVj4PP80/DMQeCcvkXPBl5c5j22V9V8Vc3Pzc2NUoYkaRVGCvokG/peXgMsHpHzIHBtkjclORfYDPzNeCVKksYx9KibJPcClwKnJzkIfBK4NMkWesMyzwMfAqiqp5J8Cfhb4Chwg0fcSNJsDQ36qrpuQPMdKyz/O8DvjFOUJGlyPDNWkhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGjc06JPsSHIkyd6+tj9I8nSSPUkeSHJK174pyY+S7O4en1vL4iVJw61mj/5O4IolbQ8DP1tV/wr4NnBz37wDVbWle3x4MmVKkkY1NOir6jHg+0vavlpVR7uXjwNnr0FtkqQJmMQY/W8Af9b3+twk30zytSSXTOD9JUljOHmclZPcAhwF7umaDgEbq+qlJD8H/I8kP1NVLw9YdxuwDWDjxo3jlCFJWsHIe/RJtgK/BPzHqiqAqnq1ql7qpncBB4DzB61fVdurar6q5ufm5kYtQ5I0xEhBn+QK4OPAe6vqlb72uSQnddPnAZuB5yZRqCRpNEOHbpLcC1wKnJ7kIPBJekfZvAl4OAnA490RNu8C/kuSo8BrwIer6vsD31iSNBVDg76qrhvQfMcyy94P3D9uUZKkyfHMWElqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNG+syxVKLbnv42yvO/9h7Bl6QVVq33KOXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjVvV4ZVJdtC7EfiRqvrZru004D5gE/A88IGq+of07i34X4GrgFeAX6uqJyZfujQbKx1++TEPWNY6tNo9+juBK5a03QQ8UlWbgUe61wBX0rsp+GZgG3D7+GVKkka1qqCvqseApTf5vhq4q5u+C3hfX/vd1fM4cEqSDZMoVpJ07MYZoz+zqg4BdM9ndO1nAd/tW+5g1/Y6SbYl2Zlk58LCwhhlSJJWshY/xmZAW/1/DVXbq2q+qubn5ubWoAxJEowX9IcXh2S65yNd+0HgnL7lzgZeHGM7kqQxjHOMwIPAVuB3u+ev9LXfmOSLwM8DP1gc4pHWg2EXLZNas9rDK+8FLgVOT3IQ+CS9gP9SkuuBF4D3d4s/RO/Qyv30Dq/89QnXLEk6BqsK+qq6bplZlw9YtoAbxilKkjQ5nhkrSY0z6CWpcZ6wLbXk0U8vP++ym6dXh9YV9+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcx9FLE/TXz7204vx/c95bp1SJ9E/co5ekxhn0ktQ4h27UHK83L72eQS8do4tf2D7rEqRj4tCNJDVu5D36JG8H7utrOg/4beAU4D8BC137J6rqoZErlCSNZeSgr6pngC0ASU4Cvgc8QO/WgbdV1WcmUqEkaSyTGrq5HDhQVd+Z0PtJkiZkUkF/LXBv3+sbk+xJsiPJqRPahiRpBGMHfZI3Au8F/qRruh14G71hnUPArcusty3JziQ7FxYWBi0iSZqASezRXwk8UVWHAarqcFW9VlU/Bj4PXDRoparaXlXzVTU/Nzc3gTIkSYNMIuivo2/YJsmGvnnXAHsnsA1J0ojGOmEqyU8A7wE+1Nf8+0m2AAU8v2SeJGnKxgr6qnoFeOuStg+OVZEkaaI8M1aSGue1bqR1xOvZay0Y9NIUDQtyaS04dCNJjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY3zzFgdd257+NuzLkE6rrhHL0mNM+glqXEGvSQ1zjF6rUuOw0uTM3bQJ3ke+CHwGnC0quaTnAbcB2yidzvBD1TVP4y7LelE5/XqNYpJDd1cVlVbqmq+e30T8EhVbQYe6V5LkmZgrcborwbu6qbvAt63RtuRJA0xiaAv4KtJdiXZ1rWdWVWHALrnMyawHUnSCCbxY+w7q+rFJGcADyd5ejUrdf8obAPYuHHjBMqQJA0y9h59Vb3YPR8BHgAuAg4n2QDQPR8ZsN72qpqvqvm5ublxy5AkLWOsoE/yk0nesjgN/AKwF3gQ2NotthX4yjjbkSSNbtyhmzOBB5IsvtcXqup/JvkG8KUk1wMvAO8fczuSpBGNFfRV9Rzwrwe0vwRcPs57S5ImwzNjNROe+SpNj0EvLXHxC9tnXYI0UV7UTJIa5x69dKJ49NMrz7/s5unUoalzj16SGmfQS1LjDHpJapxBL0mNM+glqXEedSM1ZKU7UHn3qROXe/SS1DiDXpIa59CNdIIYemPxy6ZUiKbOPXpJapxBL0mNM+glqXEGvSQ1buSgT3JOkkeT7EvyVJKPdO2fSvK9JLu7x1WTK1eSdKzGOermKPBbVfVEd4PwXUke7ubdVlWfGb88SdK4Rg76qjoEHOqmf5hkH3DWpArT8c1bBUrrx0TG6JNsAi4Avt413ZhkT5IdSU5dZp1tSXYm2bmwsDCJMiRJA4wd9EneDNwPfLSqXgZuB94GbKG3x3/roPWqantVzVfV/Nzc3LhlSJKWMVbQJ3kDvZC/p6q+DFBVh6vqtar6MfB54KLxy5QkjWrkMfokAe4A9lXVZ/vaN3Tj9wDXAHvHK1HrkWPw0vFjnKNu3gl8EHgyye6u7RPAdUm2AAU8D3xorAolSWMZ56ibvwIyYNZDo5cjSZo0r14pCRg+HPex95w/pUo0aV4CQZIaZ9BLUuMMeklqnEEvSY0z6CWpcR51o4E8IerEc/EL24cs4QVpj1fu0UtS4wx6SWqcQS9JjXOMXiec4WPRUlvco5ekxhn0ktQ4g16SGucY/Qms1WPlHYNfG17d8vjlHr0kNW7Ngj7JFUmeSbI/yU1rtR1J0srWZOgmyUnAHwPvAQ4C30jyYFX97Vps70Tln9JaT/w+rl9rNUZ/EbC/qp4DSPJF4GrAoD8G446hH89j8CuNsz++cdsUK9GiYb99DPtcxvk++o/EeNYq6M8Cvtv3+iDw82u0LUla0Yn+18ZaBf2gm4bX6xZItgGLuwD/O8kzY2zvdODvx1h/LVnbaFao7dapFjLAcdpva23o5zJybb85ykrH9v7H62f6L1fzBmsV9AeBc/penw282L9AVW0HJnIcXJKdVTU/ifeaNGsbjbWNxtpG03pta3XUzTeAzUnOTfJG4FrgwTXaliRpBWuyR19VR5PcCPw5cBKwo6qeWottSZJWtmZnxlbVQ8BDa/X+S6znUyGtbTTWNhprG03TtaWqhi8lSTpueQkESWrccRX0Sd6f5KkkP04yv2Tezd3lFp5J8ot97VO/FEOS+5Ls7h7PJ9ndtW9K8qO+eZ+bRj1LavtUku/11XBV37yBfTjF2v4gydNJ9iR5IMkpXfvM+62rY91c1iPJOUkeTbKv+3/iI137sp/vlOt7PsmTXQ07u7bTkjyc5Nnu+dQZ1PX2vr7ZneTlJB+dVb8l2ZHkSJK9fW0D+yk9f9h9//YkuXDVG6qq4+YB/DTwduAvgfm+9ncA3wLeBJwLHKD3I/BJ3fR5wBu7Zd4x5ZpvBX67m94E7J1xH34K+M8D2gf24ZRr+wXg5G7694DfW0f9NvPv0pJ6NgAXdtNvAb7dfYYDP98Z1Pc8cPqStt8Hbuqmb1r8fGf8mf4veseiz6TfgHcBF/Z/v5frJ+Aq4M/onad0MfD11W7nuNqjr6p9VTXoxKqrgS9W1atV9XfAfnqXYfjHSzFU1f8BFi/FMBVJAnwAuHda2xzDcn04NVX11ao62r18nN75F+vFTL9LS1XVoap6opv+IbCP3hnp69nVwF3d9F3A+2ZYC8DlwIGq+s6sCqiqx4DvL2lerp+uBu6unseBU5JsWM12jqugX8GgSy6ctUL7tFwCHK6qZ/vazk3yzSRfS3LJFGvpd2P3p9+Ovj+fZ91XS/0Gvb2XRbPut/XWP/8oySbgAuDrXdOgz3faCvhqkl3pnQUPcGZVHYLeP1TAGTOqbdG1vH4nbD30GyzfTyN/B9dd0Cf5iyR7BzxW2nta7pILQy/FsMZ1Xsfrv0iHgI1VdQG9s7q/kOSnJlHPMdR2O/A2YEtXz+J562vWV8dQ2+IytwBHgXu6pqn027DSB7TN/JC1JG8G7gc+WlUvs/znO23vrKoLgSuBG5K8a0Z1DJTeiZzvBf6ka1ov/baSkb+D6+4OU1X17hFWW+mSCyteimFUw+pMcjLwy8DP9a3zKvBqN70ryQHgfGDnJGpabW19NX4e+NPu5dDLVkzCKvptK/BLwOXVDUxOq9+GmEr/HIskb6AX8vdU1ZcBqupw3/z+z3eqqurF7vlIkgfoDX0dTrKhqg51Qw5HZlFb50rgicX+Wi/91lmun0b+Dq67PfoRPQhcm+RNSc4FNgN/w2wvxfBu4OmqOrjYkGQuvWv1k+S8rs7nplTPYg39Y3rXAIu/9i/Xh9Os7Qrg48B7q+qVvvaZ9xvr7LIe3e8/dwD7quqzfe3Lfb7TrO0nk7xlcZrej+x76fXX1m6xrcBXpl1bn9f9tb0e+q3Pcv30IPCr3dE3FwM/WBziGWqWv3qP8Av1NfT+VXsVOAz8ed+8W+gdFfEMcGVf+1X0jkg4ANwyxVrvBD68pO1XgKfoHbHxBPDvZ9CH/w14EtjTfXE2DOvDKda2n94Y5O7u8bn10m+z/C4tU8u/pfdn+56+/rpqpc93irWd131W3+o+t1u69rcCjwDPds+nzajvfgJ4CfjnfW0z6Td6/9gcAv5vl23XL9dP9IZu/rj7/j1J35GHwx6eGStJjWtl6EaStAyDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxv0/r/ui7aB9NqEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "rng = np.random.RandomState(123)\n",
    "x1 = rng.normal(0, 20, 1000) \n",
    "x2 = rng.normal(15, 10, 1000)\n",
    "\n",
    "# fixed bin size\n",
    "bins = np.arange(-100, 100, 5) # fixed bin size\n",
    "\n",
    "plt.hist(x1, bins=bins, alpha=0.5)\n",
    "plt.hist(x2, bins=bins, alpha=0.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = range(11)\n",
    "y = range(11)\n",
    "\n",
    "fig, ax = plt.subplots(nrows=2, ncols=3,\n",
    "                       sharex=True, sharey=True)\n",
    "\n",
    "for row in ax:\n",
    "    for col in row:\n",
    "        col.plot(x, y)\n",
    "        \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colors and Markers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 100)\n",
    "plt.plot(x, np.sin(x),\n",
    "         color='orange',\n",
    "         marker='^',\n",
    "         linestyle='')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The file format for saving plots can be conveniently specified via the file suffix (.eps, .svg, .jpg, .png, .pdf, .tiff, etc.). Personally, I recommend using a vector graphics format (.eps, .svg, .pdf) whenever you can, which usually results in smaller file sizes than bitmap graphics (.jpg, .png, .bmp, tiff) and does not have a limited resolution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 100)\n",
    "plt.plot(x, np.sin(x))\n",
    "\n",
    "plt.savefig('myplot.png', dpi=300)\n",
    "plt.savefig('myplot.pdf')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are no reading assignments for this lecture. However, you should run this notebook on your computer from top to bottom at your own pace and make sure that you are comfortable with the different commands, most of which you may need for the problem sets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy and Matplotlib reference material:\n",
    "\n",
    "- [The official NumPy documentation](https://docs.scipy.org/doc/numpy/reference/index.html)\n",
    "- [The official Matplotlib Gallery](https://matplotlib.org/gallery/index.html)\n",
    "- [The official Matplotlib Tutorials](https://matplotlib.org/tutorials/index.html)\n",
    "\n",
    "\n",
    "Optional references books for using NumPy and SciPy. You are not expected to read this for this class, but I am listing it in case you are interested in learning NumPy for your projects.\n",
    "\n",
    "- Rougier, N.P., 2016. [From Python to NumPy](http://www.labri.fr/perso/nrougier/from-python-to-numpy/).\n",
    "- Oliphant, T.E., 2015. [A Guide to NumPy: 2nd Edition](https://www.amazon.com/Guide-NumPy-Travis-Oliphant-PhD/dp/151730007X). USA: Travis Oliphant, independent publishing.\n",
    "- Varoquaux, G., Gouillart, E., Vahtras, O., Haenel, V., Rougier, N.P., Gommers, R., Pedregosa, F., Jędrzejewski-Szmek, Z., Virtanen, P., Combelles, C. and Pinte, D., 2015. [SciPy Lecture Notes](http://www.scipy-lectures.org/intro/numpy/index.html).\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}