Skip to content

Instantly share code, notes, and snippets.

@CoderNamedHendrick

CoderNamedHendrick/PY0101EN-5-1-Numpy1D.ipynb

Created May 2, 2020 21:35
Show Gist options
  • Save CoderNamedHendrick/67bdfb708929c6737dfae4946820ee2f to your computer and use it in GitHub Desktop.
Save CoderNamedHendrick/67bdfb708929c6737dfae4946820ee2f 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": 2,
"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": 3,
"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": 4,
"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": 5,
"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": 6,
"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": 7,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4])"
]
},
"execution_count": 7,
"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": 8,
"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": 9,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"numpy.ndarray"
]
},
"execution_count": 9,
"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": 10,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"dtype('int64')"
]
},
"execution_count": 10,
"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": 11,
"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": 12,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"numpy.ndarray"
]
},
"execution_count": 12,
"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": 13,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"dtype('float64')"
]
},
"execution_count": 13,
"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": 14,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([20, 1, 2, 3, 4])"
]
},
"execution_count": 14,
"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": 15,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 1, 2, 3, 4])"
]
},
"execution_count": 15,
"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": 16,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 1, 2, 3, 0])"
]
},
"execution_count": 16,
"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": 17,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2, 3])"
]
},
"execution_count": 17,
"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": 18,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 1, 2, 300, 400])"
]
},
"execution_count": 18,
"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": 19,
"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": 20,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 2, 300])"
]
},
"execution_count": 20,
"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": 21,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([100000, 1, 100000, 100000, 400])"
]
},
"execution_count": 21,
"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": 22,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4])"
]
},
"execution_count": 22,
"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": 23,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 23,
"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": 24,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 24,
"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": 25,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"(5,)"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get the shape/size of numpy array\n",
"\n",
"a.shape"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"# Create a numpy array\n",
"\n",
"a = np.array([1, -1, 1, -1])"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get the mean of numpy array\n",
"\n",
"mean = a.mean()\n",
"mean"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"1.0"
]
},
"execution_count": 28,
"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": 29,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([-1, 2, 3, 4, 5])"
]
},
"execution_count": 29,
"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": 30,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 30,
"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": 31,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"-1"
]
},
"execution_count": 31,
"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": 32,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 0])"
]
},
"execution_count": 32,
"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": 33,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1])"
]
},
"execution_count": 33,
"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": 34,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 1])"
]
},
"execution_count": 34,
"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": 35,
"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": 36,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2])"
]
},
"execution_count": 36,
"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": 37,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([2, 4])"
]
},
"execution_count": 37,
"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": 38,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2])"
]
},
"execution_count": 38,
"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": 39,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([3, 2])"
]
},
"execution_count": 39,
"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": 40,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([3, 4])"
]
},
"execution_count": 40,
"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": 41,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"7"
]
},
"execution_count": 41,
"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": 42,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1, 2, 3, -1])"
]
},
"execution_count": 42,
"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": 43,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([2, 3, 4, 0])"
]
},
"execution_count": 43,
"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": 44,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"3.141592653589793"
]
},
"execution_count": 44,
"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": 45,
"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": 46,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])"
]
},
"execution_count": 46,
"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": 47,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([-2., -1., 0., 1., 2.])"
]
},
"execution_count": 47,
"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": 48,
"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": 48,
"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": 49,
"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=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": 50,
"metadata": {},
"outputs": [],
"source": [
"# Calculate the sine of x list\n",
"\n",
"y = np.sin(x)"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"collapsed": false,
"jupyter": {
"outputs_hidden": false
}
},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f5b3659b278>]"
]
},
"execution_count": 51,
"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": 52,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 1 -1]\n"
]
}
],
"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",
"print(u-v)"
]
},
{
"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": 53,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([4, 8])"
]
},
"execution_count": 53,
"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*2"
]
},
{
"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": 54,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 0, 3, 0, 5])"
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Write your code below and press Shift+Enter to execute\n",
"k = np.array([1,2,3,4,5])\n",
"l = np.array([1,0,1,0,1])\n",
"k*l"
]
},
{
"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": 55,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 55,
"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": null,
"metadata": {},
"outputs": [],
"source": [
"# Write your code below and press Shift+Enter to execute"
]
},
{
"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": null,
"metadata": {},
"outputs": [],
"source": [
"# Write your code below and press Shift+Enter to execute"
]
},
{
"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": null,
"metadata": {},
"outputs": [],
"source": [
"# Write your code below and press Shift+Enter to execute"
]
},
{
"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