Skip to content

Instantly share code, notes, and snippets.

@shohrehsharifib

shohrehsharifib/PY0101EN-5-1-Numpy1D.ipynb

Created February 17, 2021 19:53
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save shohrehsharifib/c83358b1ec0abca6cadacb09dfb6af0f to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save shohrehsharifib/c83358b1ec0abca6cadacb09dfb6af0f 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": null,
"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": 2,
"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": 3,
"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": 11,
"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": 12,
"metadata": {},
"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: \n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"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>\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": 14,
"metadata": {},
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"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>\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": 17,
"metadata": {},
"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: \n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"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>\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": 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:\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"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:\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([100000, 1, 100000, 100000, 400])"
]
},
"execution_count": 22,
"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": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4])"
]
},
"execution_count": 23,
"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": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 24,
"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": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 25,
"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": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(5,)"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get the shape/size of numpy array\n",
"\n",
"a.shape"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"# Create a numpy array\n",
"\n",
"a = np.array([1, -1, 1, -1])"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get the mean of numpy array\n",
"\n",
"mean = a.mean()\n",
"mean"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.0"
]
},
"execution_count": 29,
"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": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([-1, 2, 3, 4, 5])"
]
},
"execution_count": 30,
"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": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 31,
"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": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-1"
]
},
"execution_count": 32,
"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": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 0])"
]
},
"execution_count": 33,
"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": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1])"
]
},
"execution_count": 34,
"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": 35,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 1])"
]
},
"execution_count": 35,
"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": 97,
"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",
"def Plotvec1(u, z, v):\n",
" plt.plot(u)\n",
" plt.plot(v)\n",
" plt.plot(z)\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": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2])"
]
},
"execution_count": 38,
"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": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2, 4])"
]
},
"execution_count": 39,
"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": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2])"
]
},
"execution_count": 40,
"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": 41,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([3, 2])"
]
},
"execution_count": 41,
"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": 42,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([3, 4])"
]
},
"execution_count": 42,
"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": 46,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"7"
]
},
"execution_count": 46,
"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": 47,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1, 2, 3, -1])"
]
},
"execution_count": 47,
"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": 48,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2, 3, 4, 0])"
]
},
"execution_count": 48,
"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": 49,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3.141592653589793"
]
},
"execution_count": 49,
"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": 52,
"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": 53,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])"
]
},
"execution_count": 53,
"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": 54,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([-2., -1., 0., 1., 2.])"
]
},
"execution_count": 54,
"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": 55,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([-2. , -1.5, -1. , -0.5, 0. , 0.5, 1. , 1.5, 2. ])"
]
},
"execution_count": 55,
"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": 57,
"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": 59,
"metadata": {},
"outputs": [],
"source": [
"# Calculate the sine of x list\n",
"\n",
"y = np.sin(x)"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f53675e96d8>]"
]
},
"execution_count": 60,
"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": 61,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1, -1])"
]
},
"execution_count": 61,
"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",
"u - v"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details><summary>Click here for the solution</summary>\n",
"\n",
"```python\n",
"u - v\n",
"```\n",
"\n",
"</details>\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": 64,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([-4, -8])"
]
},
"execution_count": 64,
"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": [
"<details><summary>Click here for the solution</summary>\n",
"\n",
"```python\n",
"-2 * z\n",
"```\n",
"\n",
"</details>\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": 65,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 0, 3, 0, 5])"
]
},
"execution_count": 65,
"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",
"a * b"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details><summary>Click here for the solution</summary>\n",
"\n",
"```python\n",
"a = np.array([1, 2, 3, 4, 5])\n",
"b = np.array([1, 0, 1, 0, 1])\n",
"a * b\n",
"```\n",
"\n",
"</details>\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": 96,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The dot product is 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",
"a = np.array([-1, 1])\n",
"b = np.array([1, 1])\n",
"def Plotvec2(a,b):\n",
" plt.plot(a)\n",
" plt.plot(b)\n",
"Plotvec2(a, b)\n",
"print(\"The dot product is\", np.dot(a,b))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details><summary>Click here for the solution</summary>\n",
"\n",
"```python\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",
"```\n",
"\n",
"</details>\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": 94,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The dot product is 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",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"a = np.array([1, 0])\n",
"b = np.array([0, 1])\n",
"def Plotvec2(a,b):\n",
" plt.plot(a)\n",
" plt.plot(b)\n",
"Plotvec2(a, b)\n",
"print(\"The dot product is\", np.dot(a, b))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details><summary>Click here for the solution</summary>\n",
"\n",
"```python\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",
"```\n",
"\n",
"</details>\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": 95,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The dot product is 1\n",
"The dot product is 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",
"a = np.array([1, 1])\n",
"b = np.array([0, 1])\n",
"def Plotvec2(a,b):\n",
" plt.plot(a)\n",
" plt.plot(b)\n",
"Plotvec2(a, b)\n",
"print(\"The dot product is\", np.dot(a, b))\n",
"print(\"The dot product is\", np.dot(a, b))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details><summary>Click here for the solution</summary>\n",
"\n",
"```python\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",
"```\n",
"\n",
"</details>\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": 76,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The vectors used for question 4 and 5 are perpendicular. As a result, the dot product is zero.\n"
]
}
],
"source": [
"# Write your code below and press Shift+Enter to execute\n",
"print (\"The vectors used for question 4 and 5 are perpendicular. As a result, the dot product is zero.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details><summary>Click here for the solution</summary>\n",
"\n",
"```python\n",
"The vectors used for question 4 and 5 are perpendicular. As a result, the dot product is zero. \n",
"\n",
"```\n",
"\n",
"</details>\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.12"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment