PY0101EN-5-1-Numpy1D.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "    <a href=\"https://cocl.us/topNotebooksPython101Coursera\">\n",
    "         <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/TopAd.png\" width=\"750\" align=\"center\">\n",
    "    </a>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://cognitiveclass.ai/\">\n",
    "    <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/CCLog.png\" width=\"200\" align=\"center\">\n",
    "</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>1D <code>Numpy</code> in Python</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p><strong>Welcome!</strong> This notebook will teach you about using <code>Numpy</code> in the Python Programming Language. By the end of this lab, you'll know what <code>Numpy</code> is and the <code>Numpy</code> operations.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Table of Contents</h2>\n",
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "    <ul>\n",
    "        <li><a href=\"pre\">Preparation</a></li>\n",
    "        <li>\n",
    "            <a href=\"numpy\">What is Numpy?</a>\n",
    "            <ul>\n",
    "                <li><a href=\"type\">Type</a></li>\n",
    "                <li><a href=\"val\">Assign Value</a></li>\n",
    "                <li><a href=\"slice\">Slicing</a></li>\n",
    "                <li><a href=\"list\">Assign Value with List</a></li>\n",
    "                <li><a href=\"other\">Other Attributes</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li>\n",
    "            <a href=\"op\">Numpy Array Operations</a>\n",
    "            <ul>\n",
    "                <li><a href=\"add\">Array Addition</a></li>\n",
    "                <li><a href=\"multi\">Array Multiplication</a></li>\n",
    "                <li><a href=\"prod\">Product of Two Numpy Arrays</a></li>\n",
    "                <li><a href=\"dot\">Dot Product</a></li>\n",
    "                <li><a href=\"cons\">Adding Constant to a Numpy Array</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li><a href=\"math\">Mathematical Functions</a></li>\n",
    "        <li><a href=\"lin\">Linspace</a></li>\n",
    "    </ul>\n",
    "    <p>\n",
    "        Estimated time needed: <strong>30 min</strong>\n",
    "    </p>\n",
    "</div>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"pre\">Preparation</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the libraries\n",
    "\n",
    "import time \n",
    "import sys\n",
    "import numpy as np \n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=np.array([0,1,0,1,0])\n",
    "b=np.array([1,0,1,0,1])\n",
    "a*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting functions\n",
    "\n",
    "def Plotvec1(u, z, v):\n",
    "    \n",
    "    ax = plt.axes()\n",
    "    ax.arrow(0, 0, *u, head_width=0.05, color='r', head_length=0.1)\n",
    "    plt.text(*(u + 0.1), 'u')\n",
    "    \n",
    "    ax.arrow(0, 0, *v, head_width=0.05, color='b', head_length=0.1)\n",
    "    plt.text(*(v + 0.1), 'v')\n",
    "    ax.arrow(0, 0, *z, head_width=0.05, head_length=0.1)\n",
    "    plt.text(*(z + 0.1), 'z')\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.xlim(-2, 2)\n",
    "\n",
    "def Plotvec2(a,b):\n",
    "    ax = plt.axes()\n",
    "    ax.arrow(0, 0, *a, head_width=0.05, color ='r', head_length=0.1)\n",
    "    plt.text(*(a + 0.1), 'a')\n",
    "    ax.arrow(0, 0, *b, head_width=0.05, color ='b', head_length=0.1)\n",
    "    plt.text(*(b + 0.1), 'b')\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.xlim(-2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a Python List as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a python list\n",
    "\n",
    "a = [\"0\", 1, \"two\", \"3\", 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the data via an index:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumOneList.png\" width=\"660\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access each element using a square bracket as follows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[0]: 0\n",
      "a[1]: 1\n",
      "a[2]: two\n",
      "a[3]: 3\n",
      "a[4]: 4\n"
     ]
    }
   ],
   "source": [
    "# Print each element\n",
    "\n",
    "print(\"a[0]:\", a[0])\n",
    "print(\"a[1]:\", a[1])\n",
    "print(\"a[2]:\", a[2])\n",
    "print(\"a[3]:\", a[3])\n",
    "print(\"a[4]:\", a[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"numpy\">What is Numpy?</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A numpy array is similar to a list. It's usually fixed in size and each element is of the same type. We can cast a list to a numpy array by first importing numpy: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy library\n",
    "\n",
    "import numpy as np "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " We then cast the list as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "a = np.array([0, 1, 2, 3, 4])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each element is of the same type, in this case integers: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumOneNp.png\" width=\"500\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " As with lists, we can access each element via a square bracket:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[0]: 0\n",
      "a[1]: 1\n",
      "a[2]: 2\n",
      "a[3]: 3\n",
      "a[4]: 4\n"
     ]
    }
   ],
   "source": [
    "# Print each element\n",
    "\n",
    "print(\"a[0]:\", a[0])\n",
    "print(\"a[1]:\", a[1])\n",
    "print(\"a[2]:\", a[2])\n",
    "print(\"a[3]:\", a[3])\n",
    "print(\"a[4]:\", a[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"type\">Type</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we check the type of the array we get <b>numpy.ndarray</b>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the type of the array\n",
    "\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As numpy arrays contain data of the same type, we can use the attribute \"dtype\" to obtain the Data-type of the array’s elements. In this case a 64-bit integer: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the type of the values stored in numpy array\n",
    "\n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create a numpy array with real numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "b = np.array([3.1, 11.02, 6.2, 213.2, 5.2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we check the type of the array we get <b>numpy.ndarray</b>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the type of array\n",
    "\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we examine the attribute <code>dtype</code> we see float 64, as the elements are not integers: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the value type\n",
    "\n",
    "b.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"val\">Assign value</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the value of the array, consider the array <code>c</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  1,  2,  3,  4])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create numpy array\n",
    "\n",
    "c = np.array([20, 1, 2, 3, 4])\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the first element of the array to 100 as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2,   3,   4])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign the first element to 100\n",
    "\n",
    "c[0] = 100\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the 5th element of the array to 0 as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2,   3,   0])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign the 5th element to 0\n",
    "\n",
    "c[4] = 0\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"slice\">Slicing</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like lists, we can slice the numpy array, and we can select the elements from 1 to 3 and assign it to a new numpy array <code>d</code> as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing the numpy array\n",
    "\n",
    "d = c[1:4]\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign the corresponding indexes to  new values as follows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   1,   2, 300, 400])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set the fourth element and fifth element to 300 and 400\n",
    "\n",
    "c[3:5] = 300, 400\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"list\">Assign Value with List</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can use a list to select a specific index.\n",
    "The list ' select ' contains several values:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the index list\n",
    "\n",
    "select = [0, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the list as an argument in the brackets. The output is the elements corresponding to the particular index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   2, 300])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use List to select elements\n",
    "\n",
    "d = c[select]\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign the specified elements to a new value. For example, we can assign the values to 100 000 as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100000,      1, 100000, 100000,    400])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign the specified elements to new value\n",
    "\n",
    "c[select] = 100000\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"other\">Other Attributes</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's review some basic array attributes using the array <code>a</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "a = np.array([0, 1, 2, 3, 4])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The attribute <code>size</code> is the number of elements in the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the size of numpy array\n",
    "\n",
    "a.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next two attributes will make more sense when we get to higher dimensions but let's review them. The attribute <code>ndim</code> represents the number of array dimensions or the rank of the array, in this case, one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the number of dimensions of numpy array\n",
    "\n",
    "a.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The attribute <code>shape</code> is a tuple of integers indicating the size of the array in each dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the shape/size of numpy array\n",
    "\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "a = np.array([1, -1, 1, -1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the mean of numpy array\n",
    "\n",
    "mean = a.mean()\n",
    "mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the standard deviation of numpy array\n",
    "\n",
    "standard_deviation=a.std()\n",
    "standard_deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "b = np.array([-1, 2, 3, 4, 5])\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the biggest value in the numpy array\n",
    "\n",
    "max_b = b.max()\n",
    "max_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the smallest value in the numpy array\n",
    "\n",
    "min_b = b.min()\n",
    "min_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"op\">Numpy Array Operations</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"add\">Array Addition</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the numpy array <code>u</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = np.array([1, 0])\n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the numpy array <code>v</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.array([0, 1])\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add the two arrays and assign it to z:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy Array Addition\n",
    "\n",
    "z = u + v\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The operation is equivalent to vector addition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot numpy arrays\n",
    "\n",
    "Plotvec1(u, z, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"multi\">Array Multiplication</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the vector numpy array <code>y</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "y = np.array([1, 2])\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can multiply every element in the array by 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy Array Multiplication\n",
    "\n",
    "z = 2 * y\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " This is equivalent to multiplying a vector by a scaler: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"prod\">Product of Two Numpy Arrays</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following array <code>u</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "u = np.array([1, 2])\n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following array <code>v</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 2])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a numpy array\n",
    "\n",
    "v = np.array([3, 2])\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The product of the two numpy arrays <code>u</code> and <code>v</code> is given by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the production of two numpy arrays\n",
    "\n",
    "z = u * v\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"dot\">Dot Product</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dot product of the two numpy arrays <code>u</code> and <code>v</code> is given by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the dot product\n",
    "\n",
    "np.dot(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"cons\">Adding Constant to a Numpy Array</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following array: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3, -1])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a constant to numpy array\n",
    "\n",
    "u = np.array([1, 2, 3, -1]) \n",
    "u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding the constant 1 to each element in the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 0])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add the constant to array\n",
    "\n",
    "u + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The process is summarised in the following animation:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumOneAdd.gif\" width=\"500\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"math\">Mathematical Functions</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " We can access the value of pie in numpy as follows :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The value of pie\n",
    "\n",
    "np.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " We can create the following numpy array in Radians:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the numpy array in radians\n",
    "\n",
    "x = np.array([0, np.pi/2 , np.pi])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply the function <code>sin</code> to the array <code>x</code> and assign the values to the array <code>y</code>; this applies the sine function to each element in the array:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculate the sin of each elements\n",
    "\n",
    "y = np.sin(x)\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"lin\">Linspace</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " A useful function for plotting mathematical functions is \"linespace\".   Linespace returns evenly spaced numbers over a specified interval. We specify the starting point of the sequence and the ending point of the sequence. The parameter \"num\" indicates the Number of samples to generate, in this case 5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2., -1.,  0.,  1.,  2.])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Makeup a numpy array within [-2, 2] and 5 elements\n",
    "\n",
    "np.linspace(-2, 2, num=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we change the parameter <code>num</code> to 9, we get 9 evenly spaced numbers over the interval from -2 to 2: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2. , -1.5, -1. , -0.5,  0. ,  0.5,  1. ,  1.5,  2. ])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Makeup a numpy array within [-2, 2] and 9 elements\n",
    "\n",
    "np.linspace(-2, 2, num=9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the function line space to generate 100 evenly spaced samples from the interval 0 to 2π: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Makeup a numpy array within [0, 2π] and 100 elements \n",
    "\n",
    "x = np.linspace(0, 2*np.pi, num=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply the sine function to each element in the array <code>x</code> and assign it to the array <code>y</code>: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the sine of x list\n",
    "\n",
    "y = np.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fcf401c4828>]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the result\n",
    "\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"quiz\">Quiz on 1D Numpy Array</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement the following vector subtraction in numpy: u-v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -1])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "\n",
    "u = np.array([1, 0])\n",
    "v = np.array([0, 1])\n",
    "z = u-v\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- Your answer is below:\n",
    "u - v\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiply the numpy array z with -2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-4, -8])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "\n",
    "z = np.array([2, 4])\n",
    "z=z*-2\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- Your answer is below:\n",
    "-2 * z\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the list <code>[1, 2, 3, 4, 5]</code> and <code>[1, 0, 1, 0, 1]</code>, and cast both lists to a numpy array then multiply them together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 3, 0, 5])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "a=np.array([1,2,3,4,5])\n",
    "b=np.array([1,0,1,0,1])\n",
    "z=a*b\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- Your answer is below:\n",
    "a = np.array([1, 2, 3, 4, 5])\n",
    "b = np.array([1, 0, 1, 0, 1])\n",
    "a * b\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the list <code>[-1, 1]</code> and <code>[1, 1]</code> to numpy arrays <code>a</code> and <code>b</code>.  Then, plot the arrays as vectors using the fuction <code>Plotvec2</code> and find the dot product:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "a=np.array([-1,1])\n",
    "b=np.array([1,1])\n",
    "Plotvec2(a,b)\n",
    "z=np.dot(a,b)\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- Your answer is below:\n",
    "a = np.array([-1, 1])\n",
    "b = np.array([1, 1])\n",
    "Plotvec2(a, b)\n",
    "print(\"The dot product is\", np.dot(a,b))\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the list <code>[1, 0]</code> and <code>[0, 1]</code> to numpy arrays <code>a</code> and <code>b</code>. Then, plot the arrays as vectors using the function <code>Plotvec2</code> and find the dot product:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "a=np.array([1,0])\n",
    "b=np.array([0,1])\n",
    "Plotvec2(a,b)\n",
    "z=np.dot(a,b)\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- \n",
    "a = np.array([1, 0])\n",
    "b = np.array([0, 1])\n",
    "Plotvec2(a, b)\n",
    "print(\"The dot product is\", np.dot(a, b))\n",
    " -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the list <code>[1, 1]</code> and <code>[0, 1]</code> to numpy arrays <code>a</code> and <code>b</code>. Then plot the arrays as vectors using the fuction <code>Plotvec2</code> and find the dot product:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "a=np.array([1,1])\n",
    "b=np.array([0,1])\n",
    "Plotvec2(a,b)\n",
    "z=np.dot(a,b)\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- \n",
    "a = np.array([1, 1])\n",
    "b = np.array([0, 1])\n",
    "Plotvec2(a, b)\n",
    "print(\"The dot product is\", np.dot(a, b))\n",
    "print(\"The dot product is\", np.dot(a, b))\n",
    " -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why are the results of the dot product for <code>[-1, 1]</code> and <code>[1, 1]</code> and the dot product for <code>[1, 0]</code> and <code>[0, 1]</code> zero, but not zero for the dot product for <code>[1, 1]</code> and <code>[0, 1]</code>? <p><i>Hint: Study the corresponding figures, pay attention to the direction the arrows are pointing to.</i></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-83-d1b367979ccd>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-83-d1b367979ccd>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    vectors are at 90 degree in first two cases.\u001b[0m\n\u001b[0m              ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute \n",
    "vectors are at 90 degree in first two cases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-click __here__ for the solution.\n",
    "\n",
    "<!-- \n",
    "The vectors used for question 4 and 5 are perpendicular. As a result, the dot product is zero. \n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<h2>The last exercise!</h2>\n",
    "<p>Congratulations, you have completed your first lesson and hands-on lab in Python. However, there is one more thing you need to do. The Data Science community encourages sharing work. The best way to share and showcase your work is to share it on GitHub. By sharing your notebook on GitHub you are not only building your reputation with fellow data scientists, but you can also show it off when applying for a job. Even though this was your first piece of work, it is never too early to start building good habits. So, please read and follow <a href=\"https://cognitiveclass.ai/blog/data-scientists-stand-out-by-sharing-your-notebooks/\" target=\"_blank\">this article</a> to learn how to share your work.\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "<h2>Get IBM Watson Studio free of charge!</h2>\n",
    "    <p><a href=\"https://cocl.us/bottemNotebooksPython101Coursera\"><img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/BottomAd.png\" width=\"750\" align=\"center\"></a></p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>About the Authors:</h3>  \n",
    "<p><a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\" target=\"_blank\">Joseph Santarcangelo</a> is a Data Scientist at IBM, and holds a PhD in Electrical Engineering. His research focused on using Machine Learning, Signal Processing, and Computer Vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other contributors: <a href=\"www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Copyright &copy; 2018 IBM Developer Skills Network. This notebook and its source code are released under the terms of the <a href=\"https://cognitiveclass.ai/mit-license/\">MIT License</a>.</p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}