Skip to content

Instantly share code, notes, and snippets.

@milan-vishnoi

milan-vishnoi/PY0101EN-5-1-Numpy1D.ipynb

Created June 24, 2020 20:01
Show Gist options
  • Save milan-vishnoi/82470563f0a15ad06fe58254e88b4a9d to your computer and use it in GitHub Desktop.
Save milan-vishnoi/82470563f0a15ad06fe58254e88b4a9d to your computer and use it in GitHub Desktop.
Download ZIP
Created on Skills Network Labs
Display the source blob
Display the rendered blob
Raw
PY0101EN-5-1-Numpy1D.ipynb
{
"cells": [
{
"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": [
"<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
" <a href=\"https://cocl.us/NotebooksPython101\">\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": [
"<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": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"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": 3,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"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": 4,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"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": 5,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"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": 17,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4])"
]
},
"execution_count": 17,
"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": 19,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"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": 20,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"numpy.ndarray"
]
},
"execution_count": 20,
"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": 21,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"dtype('int64')"
]
},
"execution_count": 21,
"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": 22,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"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": 23,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"numpy.ndarray"
]
},
"execution_count": 23,
"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": 24,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"dtype('float64')"
]
},
"execution_count": 24,
"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": 25,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([20, 1, 2, 3, 4])"
]
},
"execution_count": 25,
"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": 26,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 1, 2, 3, 4])"
]
},
"execution_count": 26,
"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": 27,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 1, 2, 3, 0])"
]
},
"execution_count": 27,
"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": 28,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2, 3])"
]
},
"execution_count": 28,
"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": 29,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 1, 2, 300, 400])"
]
},
"execution_count": 29,
"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": 35,
"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": 31,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 2, 300])"
]
},
"execution_count": 31,
"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": 32,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([100000, 1, 100000, 100000, 400])"
]
},
"execution_count": 32,
"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": 33,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4])"
]
},
"execution_count": 33,
"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": 34,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 34,
"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": 36,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 36,
"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": 37,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"(5,)"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get the shape/size of numpy array\n",
"\n",
"a.shape"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [],
"source": [
"# Create a numpy array\n",
"\n",
"a = np.array([1, -1, 1, -1])"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get the mean of numpy array\n",
"\n",
"mean = a.mean()\n",
"mean"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"1.0"
]
},
"execution_count": 41,
"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": 42,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([-1, 2, 3, 4, 5])"
]
},
"execution_count": 42,
"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": 43,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 43,
"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": 44,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"-1"
]
},
"execution_count": 44,
"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": 45,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 0])"
]
},
"execution_count": 45,
"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": 46,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1])"
]
},
"execution_count": 46,
"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": 47,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 1])"
]
},
"execution_count": 47,
"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": 48,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"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": 49,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2])"
]
},
"execution_count": 49,
"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": 50,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([2, 4])"
]
},
"execution_count": 50,
"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": 51,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2])"
]
},
"execution_count": 51,
"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": 52,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([3, 2])"
]
},
"execution_count": 52,
"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": 53,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([3, 4])"
]
},
"execution_count": 53,
"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": 54,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"7"
]
},
"execution_count": 54,
"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": 55,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1, 2, 3, -1])"
]
},
"execution_count": 55,
"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": 56,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([2, 3, 4, 0])"
]
},
"execution_count": 56,
"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": 57,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"3.141592653589793"
]
},
"execution_count": 57,
"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": 58,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"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": 59,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])"
]
},
"execution_count": 59,
"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": 60,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([-2., -1., 0., 1., 2.])"
]
},
"execution_count": 60,
"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": 61,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([-2. , -1.5, -1. , -0.5, 0. , 0.5, 1. , 1.5, 2. ])"
]
},
"execution_count": 61,
"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": 72,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [],
"source": [
"# Makeup a numpy array within [0, 2π] and 100 elements \n",
"\n",
"x = np.linspace(0, 2*np.pi, num=180)"
]
},
{
"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": 80,
"metadata": {},
"outputs": [],
"source": [
"# Calculate the sine of x list\n",
"\n",
"y = np.sin(x)"
]
},
{
"cell_type": "code",
"execution_count": 81,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7ff10ea73400>]"
]
},
"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": [
"# 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": 83,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1, -1])"
]
},
"execution_count": 83,
"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": 84,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([-4, -8])"
]
},
"execution_count": 84,
"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": 87,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 0, 3, 0, 5])"
]
},
"execution_count": 87,
"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": 93,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 93,
"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",
"np.dot(a,b)"
]
},
{
"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": 91,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 91,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD8CAYAAAB3u9PLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAASdUlEQVR4nO3dbYyd5X3n8e8PsBNhQIRggjF2kqrWBoicLQyOWaKVqyaRsaI1aUhF1GzcpNIoKKittC/CLkr6drsrVSqbB3ZWRQUJkVZpnVgb8xg1cpEgZUzBsbFdXMTGlt3YhMgBmZQ4/PfFudJMhzOeGZ97zhmb70c6OvfDde7rr4vx+XE/nlQVkiSdM+oCJEmLg4EgSQIMBElSYyBIkgADQZLUGAiSJKCDQEiyKsnfJtmbZE+SP+zTJknuSnIgya4k1w7arySpW+d1sI2TwH+pqqeTXAjsTPJoVT03pc1NwJr2+iDw9fYuSVokBt5DqKojVfV0m34F2AusnNZsM3Bf9TwJXJxkxaB9S5K608Uewr9K8h7gN4DvT1u1Ejg4Zf5QW3akzzbGgXGAZcuWXfe+972vyxIl6ay2c+fOl6pq+el8trNASHIB8NfAH1XVT6ev7vORvs/MqKoJYAJgbGysJicnuypRks56Sf7f6X62k6uMkiyhFwb3V9Xf9GlyCFg1Zf5K4HAXfUuSutHFVUYB/hzYW1V/OkOzbcBn2tVG64HjVfWmw0WSpNHp4pDRjcB/Bn6Q5Jm27L8BqwGq6m5gO7AJOACcAD7bQb+SpA4NHAhV9Tj9zxFMbVPAFwbtS5K0cLxTWZIEGAiSpMZAkCQBBoIkqTEQJEmAgSBJagwESRJgIEiSGgNBkgQYCJKkxkCQJAEGgiSpMRAkSYCBIElqDARJEmAgSJIaA0GSBBgIkqSmk0BIck+So0l2z7B+Q5LjSZ5pry930a8kqTsD/6Zy8xfAV4D7TtHm76rqYx31J0nqWCd7CFW1A3i5i21JkkZjmOcQbkjybJIHk1wzxH4lSXPQ1SGj2TwNvLuqXk2yCfgWsKZfwyTjwDjA6tWrh1SeJGkoewhV9dOqerVNbweWJLl0hrYTVTVWVWPLly8fRnmSJIYUCEkuT5I2va71++Nh9C1JmptODhkleQDYAFya5BDwx8ASgKq6G7gFuC3JSeA14Naqqi76liR1o5NAqKpPzbL+K/QuS5UkLVLeqSxJAgwESVJjIEiSAANBktQYCJIkwECQJDUGgiQJMBAkSY2BIEkCDARpwbz44ou8//3vH3UZ0pwZCJIkwECQFtTJkyfZsmULa9eu5ZZbbuHEiROjLkmakYEgLaD9+/czPj7Orl27uOiii/ja17426pKkGRkI0gJatWoVN954IwCf/vSnefzxx0dckTQzA0FaQO13oWaclxYTA0FaQD/84Q954oknAHjggQf40Ic+NOKKpJkZCNI8/e7vwm23za3tVVddxb333svatWt5+eWXuW2uH5RGIIv5lyzHxsZqcnJy1GVI/+onP4EVK+Ccc+Cll+D880ddkfRvJdlZVWOn81n3EKR5uP9+OPfc3uub3xx1NVK3OgmEJPckOZpk9wzrk+SuJAeS7EpybRf9SsP2Z38GJ07Aq6/2pqWzSVd7CH8BbDzF+puANe01Dny9o36lofmHf4DDh381/9xzcODA6OqRutZJIFTVDuDlUzTZDNxXPU8CFydZ0UXf0rA89BD8/Oe/mv/FL+CRR0ZXj9S1YZ1DWAkcnDJ/qC17kyTjSSaTTB47dmwoxUlz8Qd/ADt2/Gp+xw743OdGV4/UtWEFQr+7cfpe3lRVE1U1VlVjy5cvX+CypLlbtgzWr+9NX3BBb/rtbx9tTVKXhhUIh4BVU+avBA7P0FaSNALDCoRtwGfa1UbrgeNVdWRIfUuS5uC8LjaS5AFgA3BpkkPAHwNLAKrqbmA7sAk4AJwAPttFv5Kk7nQSCFX1qVnWF/CFLvqSJC0M71SWJAEGgiSpMRAkSYCBIElqDARJEmAgSJIaA0GSBBgIkqTGQJAkAQaCJKkxECRJgIEgSWoMBEkSYCBIkhoDQZIEGAiSpMZAkCQBBoIkqekkEJJsTLI/yYEkd/RZvyHJ8STPtNeXu+hXktSdgX9TOcm5wFeBjwCHgKeSbKuq56Y1/buq+tig/UmSFkYXewjrgANV9UJVvQ58A9jcwXYlSUPURSCsBA5OmT/Ulk13Q5JnkzyY5JqZNpZkPMlkksljx451UJ4kaS66CIT0WVbT5p8G3l1VHwD+F/CtmTZWVRNVNVZVY8uXL++gPEnSXHQRCIeAVVPmrwQOT21QVT+tqlfb9HZgSZJLO+hbktSRLgLhKWBNkvcmWQrcCmyb2iDJ5UnSpte1fn/cQd+SpI4MfJVRVZ1McjvwMHAucE9V7Uny+bb+buAW4LYkJ4HXgFuravphJUnSCGUxfy+PjY3V5OTkqMuQ/o0ELrgAXnll1JVIb5ZkZ1WNnc5nvVNZkgQYCJKkxkCQJAEGgiSpMRAkSYCBIElqDARJEmAgSJIaA0GSBBgIkqTGQJB0xrj55pu57rrruOaaa5iYmBh1OWedgR9uJ0nDcs8993DJJZfw2muvcf311/OJT3yCd77znaMu66xhIEg6Y9x1111s3boVgIMHD/L8888bCB0yECSdEb73ve/x2GOP8cQTT3D++eezYcMGfvazn426rLOK5xAknRGOHz/OO97xDs4//3z27dvHk08+OeqSzjoGgqQzwsaNGzl58iRr167lS1/6EuvXrx91SWcdDxlJOiO87W1v48EHHxx1GWc19xAkSUBHgZBkY5L9SQ4kuaPP+iS5q63fleTaLvqVJHVn4ENGSc4Fvgp8BDgEPJVkW1U9N6XZTcCa9vog8PX2Lumt7otfhN274frr4Zpr4OqrYc0aWLp01JW95XRxDmEdcKCqXgBI8g1gMzA1EDYD91VVAU8muTjJiqo60kH/0lAtXVJc/PpRuGrDqEs5O+zb13t/6CFYtqw3/dprcNllcNVVcN11cOedcNFFo6vxLaKLQFgJHJwyf4g3/99/vzYrgTcFQpJxYBxg9erVHZQndWvH/9nP23/vd371RaZuvPEGnDjRC4WlS+Gf/xkSOOcceP31UVf3ltBFIKTPsjqNNr2FVRPABMDY2FjfNtIofXDL+2DLrlGXcfa45RZ4+une4aKph41+/ddhyZJRV/eW0kUgHAJWTZm/Ejh8Gm0kvRV985ujrkBNF1cZPQWsSfLeJEuBW4Ft09psAz7TrjZaDxz3/IEkLS4D7yFU1ckktwMPA+cC91TVniSfb+vvBrYDm4ADwAngs4P2K0nqVid3KlfVdnpf+lOX3T1luoAvdNGXJGlheKeyJAkwECRJjYEgSQIMBElSYyBIkgADQZLUGAiSJMBAkCQ1BoIkCTAQJEmNgSBJAgwESVJjIEiSAANBktQYCJIkwECQJDUGgiQJMBAkSc1AP6GZ5BLgL4H3AC8Cv1NVP+nT7kXgFeAXwMmqGhukX0lS9wbdQ7gD+G5VrQG+2+Zn8ptV9e8NA0lanAYNhM3AvW36XuDmAbcnSRqRQQPhXVV1BKC9XzZDuwIeSbIzyfipNphkPMlkksljx44NWJ4kaa5mPYeQ5DHg8j6r7pxHPzdW1eEklwGPJtlXVTv6NayqCWACYGxsrObRhyRpALMGQlV9eKZ1SX6UZEVVHUmyAjg6wzYOt/ejSbYC64C+gSBJGo1BDxltA7a06S3At6c3SLIsyYW/nAY+CuwesF9JUscGDYT/DnwkyfPAR9o8Sa5Isr21eRfweJJngb8HvlNVDw3YrySpYwPdh1BVPwZ+q8/yw8CmNv0C8IFB+pEkLTzvVJYkAQaCJKkxECRJgIEgSWoMBEkSYCBIkhoDQZIEGAiSpMZAkCQBBoIkqTEQJEmAgSBJagwESRJgIEiSGgNBkgQYCJKkxkCQJAEGgiSpGSgQknwyyZ4kbyQZO0W7jUn2JzmQ5I5B+pQkLYxB9xB2A78N7JipQZJzga8CNwFXA59KcvWA/UqSOnbeIB+uqr0ASU7VbB1woKpeaG2/AWwGnhukb0lSt4ZxDmElcHDK/KG2rK8k40kmk0weO3ZswYuTJPXMuoeQ5DHg8j6r7qyqb8+hj367DzVT46qaACYAxsbGZmwnSerWrIFQVR8esI9DwKop81cChwfcpiSpY8M4ZPQUsCbJe5MsBW4Ftg2hX0nSPAx62enHkxwCbgC+k+ThtvyKJNsBquokcDvwMLAX+Kuq2jNY2ZKkrg16ldFWYGuf5YeBTVPmtwPbB+lLkrSwvFNZkgQYCJKkxkCQJAEGgiSpMRAkSYCBIElqDARJEmAgSJIaA0GSBBgIkqTGQJAkAQaCJKkxECRJgIEgSWoMBEkSYCBIkhoDQZIEGAiSpGbQ31T+ZJI9Sd5IMnaKdi8m+UGSZ5JMDtKnJGlhDPSbysBu4LeB/z2Htr9ZVS8N2J8kaYEMFAhVtRcgSTfVSJJGZljnEAp4JMnOJOND6lOSNA+z7iEkeQy4vM+qO6vq23Ps58aqOpzkMuDRJPuqascM/Y0D4wCrV6+e4+YlSYOaNRCq6sODdlJVh9v70SRbgXVA30CoqglgAmBsbKwG7VuSNDcLfsgoybIkF/5yGvgovZPRkqRFZNDLTj+e5BBwA/CdJA+35Vck2d6avQt4PMmzwN8D36mqhwbpV5LUvUGvMtoKbO2z/DCwqU2/AHxgkH4kSQvPO5UlSYCBIElqDARJEmAgSJIaA0GSBBgIkqTGQJAkAQaCJKkxECRJgIEgSWoMBEkSYCBIkhoDQZIEGAiSpMZAkCQBBoIkqTEQJEmAgSBJagwESRIwYCAk+Z9J9iXZlWRrkotnaLcxyf4kB5LcMUifkqSFMegewqPA+6tqLfCPwH+d3iDJucBXgZuAq4FPJbl6wH4lSR0bKBCq6pGqOtlmnwSu7NNsHXCgql6oqteBbwCbB+lXktS98zrc1ueAv+yzfCVwcMr8IeCDM20kyTgw3mb/JcnuzipcGJcCL426iDmwzm5ZZ7esszv/7nQ/OGsgJHkMuLzPqjur6tutzZ3ASeD+fpvos6xm6q+qJoCJtt3JqhqbrcZROhNqBOvsmnV2yzq7k2TydD87ayBU1Ydn6XwL8DHgt6qq3xf9IWDVlPkrgcPzKVKStPAGvcpoI/BF4D9V1YkZmj0FrEny3iRLgVuBbYP0K0nq3qBXGX0FuBB4NMkzSe4GSHJFku0A7aTz7cDDwF7gr6pqzxy3PzFgfcNwJtQI1tk16+yWdXbntGtM/6M8kqS3Gu9UliQBBoIkqVk0gXCmPAYjySeT7EnyRpIZLz9L8mKSH7RzK6d9Gdjpmkedox7PS5I8muT59v6OGdqNZDxnG5/03NXW70py7bBqm0eNG5Icb2P3TJIvD7vGVsc9SY7OdG/RYhjLVsdsdY58PJOsSvK3Sfa2f+d/2KfN/MezqhbFC/gocF6b/hPgT/q0ORf4J+DXgKXAs8DVQ67zKno3fnwPGDtFuxeBS0c4nrPWuUjG838Ad7TpO/r9dx/VeM5lfIBNwIP07rdZD3x/Eda4Afi/o/pbnFLHfwSuBXbPsH6kYzmPOkc+nsAK4No2fSG9RwcN/Le5aPYQ6gx5DEZV7a2q/cPs83TMsc6Rj2fr7942fS9w85D7P5W5jM9m4L7qeRK4OMmKRVbjolBVO4CXT9Fk1GMJzKnOkauqI1X1dJt+hd4VnCunNZv3eC6aQJjmc/SSbbp+j8GYPgiLRQGPJNnZHsexGC2G8XxXVR2B3h85cNkM7UYxnnMZn1GP4Vz7vyHJs0keTHLNcEqbt1GP5XwsmvFM8h7gN4DvT1s17/Hs8llGsxr2YzBO11zqnIMbq+pwksvo3aexr/2fR2c6qHPk4zmPzSz4ePYxl/EZyhiewlz6fxp4d1W9mmQT8C1gzYJXNn+jHsu5WjTjmeQC4K+BP6qqn05f3ecjpxzPoQZCnSGPwZitzjlu43B7P5pkK71d+06/wDqoc+TjmeRHSVZU1ZG2O3t0hm0s+Hj2MZfxGfWjWWbtf+oXRVVtT/K1JJdW1WJ7SNuox3JOFst4JllCLwzur6q/6dNk3uO5aA4Z5Sx6DEaSZUku/OU0vRPmi/GprYthPLcBW9r0FuBNezYjHM+5jM824DPtio71wPFfHgIbkllrTHJ5krTpdfT+3f94iDXO1ajHck4Ww3i2/v8c2FtVfzpDs/mP5yjPlE87I36A3vGuZ9rr7rb8CmD7tDPn/0jvyoo7R1Dnx+kl778APwIenl4nvSs+nm2vPYu1zkUynu8Evgs8394vWUzj2W98gM8Dn2/TofcDUP8E/IBTXHk2whpvb+P2LL0LNv7DsGtsdTwAHAF+3v42f3+xjeUc6xz5eAIfonf4Z9eU78xNg46nj66QJAGL6JCRJGm0DARJEmAgSJIaA0GSBBgIkqTGQJAkAQaCJKn5/6zAqxiW9oYdAAAAAElFTkSuQmCC\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",
"np.dot(a,b)"
]
},
{
"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": 92,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 92,
"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",
"np.dot(a,b)"
]
},
{
"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": 95,
"metadata": {},
"outputs": [],
"source": [
"# Write your code below and press Shift+Enter to execute\n",
"#Perpendicular"
]
},
{
"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/NotebooksPython101bottom\"><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",
"language": "python",
"name": "conda-env-python-py"
},
"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.10"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment