Skip to content

Instantly share code, notes, and snippets.

@mwy912

mwy912/PY0101EN-5-1-Numpy1D.ipynb

Created October 15, 2020 20:19
Show Gist options
  • Save mwy912/24b08a8cc2f127f89364974ffafde2ae to your computer and use it in GitHub Desktop.
Save mwy912/24b08a8cc2f127f89364974ffafde2ae 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": [
"<center>\n",
" <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/Logos/organization_logo/organization_logo.png\" width=\"300\" alt=\"cognitiveclass.ai logo\" />\n",
"</center>\n",
"\n",
"# 1D Numpy in Python\n",
"\n",
"Estimated time needed: **30** minutes\n",
"\n",
"## Objectives\n",
"\n",
"After completing this lab you will be able to:\n",
"\n",
"- Import and use `numpy` library\n",
"- Perform operations with `numpy`\n"
]
},
{
"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",
"\n",
"</div>\n",
"\n",
"<hr>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"pre\">Preparation</h2>\n"
]
},
{
"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": [],
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"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:\n"
]
},
{
"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\" />\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can access each element using a square bracket as follows: \n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"numpy\">What is Numpy?</h2>\n"
]
},
{
"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: \n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# import numpy library\n",
"\n",
"import numpy as np "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" We then cast the list as follows:\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4])"
]
},
"execution_count": 6,
"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: \n"
]
},
{
"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\" />\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" As with lists, we can access each element via a square bracket:\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If we check the type of the array we get <b>numpy.ndarray</b>:\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"numpy.ndarray"
]
},
"execution_count": 8,
"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": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dtype('int64')"
]
},
"execution_count": 9,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"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>:\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"numpy.ndarray"
]
},
"execution_count": 11,
"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: \n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dtype('float64')"
]
},
"execution_count": 12,
"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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can change the value of the array, consider the array <code>c</code>:\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([20, 1, 2, 3, 4])"
]
},
"execution_count": 13,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 1, 2, 3, 4])"
]
},
"execution_count": 14,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 1, 2, 3, 0])"
]
},
"execution_count": 15,
"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>\n"
]
},
{
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2, 3])"
]
},
"execution_count": 16,
"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: \n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 1, 2, 300, 400])"
]
},
"execution_count": 17,
"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>\n"
]
},
{
"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": 18,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([100, 2, 300])"
]
},
"execution_count": 19,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([100000, 1, 100000, 100000, 400])"
]
},
"execution_count": 20,
"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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's review some basic array attributes using the array <code>a</code>:\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4])"
]
},
"execution_count": 21,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 22,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 23,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(5,)"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get the shape/size of numpy array\n",
"\n",
"a.shape"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"# Create a numpy array\n",
"\n",
"a = np.array([1, -1, 1, -1])"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get the mean of numpy array\n",
"\n",
"mean = a.mean()\n",
"mean"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.0"
]
},
"execution_count": 27,
"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": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([-1, 2, 3, 4, 5])"
]
},
"execution_count": 28,
"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": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 29,
"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": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-1"
]
},
"execution_count": 30,
"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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"op\">Numpy Array Operations</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3 id=\"add\">Array Addition</h3>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Consider the numpy array <code>u</code>:\n"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 0])"
]
},
"execution_count": 31,
"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>:\n"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1])"
]
},
"execution_count": 32,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 1])"
]
},
"execution_count": 33,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 34,
"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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Consider the vector numpy array <code>y</code>:\n"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2])"
]
},
"execution_count": 35,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2, 4])"
]
},
"execution_count": 36,
"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: \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h3 id=\"prod\">Product of Two Numpy Arrays</h3>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Consider the following array <code>u</code>:\n"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2])"
]
},
"execution_count": 37,
"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>:\n"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([3, 2])"
]
},
"execution_count": 38,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([3, 4])"
]
},
"execution_count": 39,
"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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The dot product of the two numpy arrays <code>u</code> and <code>v</code> is given by:\n"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"7"
]
},
"execution_count": 40,
"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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Consider the following array: \n"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1, 2, 3, -1])"
]
},
"execution_count": 41,
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2, 3, 4, 0])"
]
},
"execution_count": 42,
"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:\n"
]
},
{
"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\" />\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"math\">Mathematical Functions</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" We can access the value of <code>pi</code> in numpy as follows :\n"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3.141592653589793"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# The value of pi\n",
"\n",
"np.pi"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" We can create the following numpy array in Radians:\n"
]
},
{
"cell_type": "code",
"execution_count": 44,
"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: \n"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])"
]
},
"execution_count": 45,
"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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"lin\">Linspace</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" A useful function for plotting mathematical functions is <code>linspace</code>. Linspace 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:\n"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([-2., -1., 0., 1., 2.])"
]
},
"execution_count": 46,
"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: \n"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([-2. , -1.5, -1. , -0.5, 0. , 0.5, 1. , 1.5, 2. ])"
]
},
"execution_count": 47,
"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 <code>linspace</code> to generate 100 evenly spaced samples from the interval 0 to 2π: \n"
]
},
{
"cell_type": "code",
"execution_count": 48,
"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>: \n"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [],
"source": [
"# Calculate the sine of x list\n",
"\n",
"y = np.sin(x)"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7ff350d24400>]"
]
},
"execution_count": 50,
"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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"quiz\">Quiz on 1D Numpy Array</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Implement the following vector subtraction in numpy: u-v\n"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1, -1])"
]
},
"execution_count": 51,
"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",
"\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",
"-->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Multiply the numpy array z with -2:\n"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([-4, -8])"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Write your code below and press Shift+Enter to execute\n",
"\n",
"z = np.array([2, 4])\n",
"\n",
"z * -2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Double-click **here** for the solution.\n",
"\n",
"<!-- Your answer is below:\n",
"-2 * z\n",
"-->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n"
]
},
{
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 0, 3, 0, 5])"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Write your code below and press Shift+Enter to execute\n",
"\n",
"list1 = [1,2,3,4,5]\n",
"list2 = [1,0,1,0,1]\n",
"\n",
"a = np.array(list1)\n",
"b = np.array(list2)\n",
"\n",
"a*b"
]
},
{
"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",
"-->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n"
]
},
{
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 57,
"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",
"\n",
"a = np.array([-1,1])\n",
"b = np.array([1,1])\n",
"\n",
"Plotvec2(a,b)\n",
"\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",
"-->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n"
]
},
{
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"the dot product = 0\n"
]
},
{
"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",
"\n",
"\n",
"a = np.array([1,0])\n",
"b = np.array([0,1])\n",
"\n",
"Plotvec2(a,b)\n",
"\n",
"print(\"the dot product = \",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",
" -->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n"
]
},
{
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"the dot product = 1\n"
]
},
{
"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",
"\n",
"\n",
"a = np.array([1,1])\n",
"b = np.array([0,1])\n",
"\n",
"Plotvec2(a,b)\n",
"\n",
"print(\"the dot product = \",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",
" -->\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n"
]
},
{
"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>\n"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [],
"source": [
"# Write your code below and press Shift+Enter to execute\n",
"\n",
"#The two vectors are not at right angles!"
]
},
{
"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",
"-->\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>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Author\n",
"\n",
"<a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\" target=\"_blank\">Joseph Santarcangelo</a>\n",
"\n",
"## Other contributors\n",
"\n",
"<a href=\"www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a>\n",
"\n",
"## Change Log\n",
"\n",
"| Date (YYYY-MM-DD) | Version | Changed By | Change Description |\n",
"| ----------------- | ------- | ---------- | ---------------------------------- |\n",
"| 2020-08-26 | 2.0 | Lavanya | Moved lab to course repo in GitLab |\n",
"| | | | |\n",
"| | | | |\n",
"\n",
"<hr/>\n",
"\n",
"## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"
]
}
],
"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.11"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment