PY0101EN-5-2-Numpy2D.ipynb

{
    "cells": [
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n    <a href=\"https://cocl.us/topNotebooksPython101Coursera\">\n         <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/TopAd.png\" width=\"750\" align=\"center\">\n    </a>\n</div>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "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>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<h1>2D <code>Numpy</code> in Python</h1>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "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>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<h2>Table of Contents</h2>\n<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n    <ul>\n        <li><a href=\"create\">Create a 2D Numpy Array</a></li>\n        <li><a href=\"access\">Accessing different elements of a Numpy Array</a></li>\n        <li><a href=\"op\">Basic Operations</a></li>\n    </ul>\n    <p>\n        Estimated time needed: <strong>20 min</strong>\n    </p>\n</div>\n\n<hr>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<h2 id=\"create\">Create a 2D Numpy Array</h2>"
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# Import the libraries\n\nimport numpy as np \nimport matplotlib.pyplot as plt",
            "execution_count": 1,
            "outputs": []
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "Consider the list <code>a</code>, the list contains three nested lists **each of equal size**. "
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Create a list\n\na = [[11, 12, 13], [21, 22, 23], [31, 32, 33]]\na",
            "execution_count": 2,
            "outputs": [
                {
                    "data": {
                        "text/plain": "[[11, 12, 13], [21, 22, 23], [31, 32, 33]]"
                    },
                    "execution_count": 2,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We can cast the list to a Numpy Array as follow"
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Convert list to Numpy Array\n# Every element is the same type\n\nA = np.array(a)\nA",
            "execution_count": 3,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[11, 12, 13],\n       [21, 22, 23],\n       [31, 32, 33]])"
                    },
                    "execution_count": 3,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We can use the attribute <code>ndim</code> to obtain the number of axes or dimensions referred to as the rank. "
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Show the numpy array dimensions\n\nA.ndim",
            "execution_count": 4,
            "outputs": [
                {
                    "data": {
                        "text/plain": "2"
                    },
                    "execution_count": 4,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "Attribute <code>shape</code> returns a tuple corresponding to the size or number of each dimension."
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Show the numpy array shape\n\nA.shape",
            "execution_count": 5,
            "outputs": [
                {
                    "data": {
                        "text/plain": "(3, 3)"
                    },
                    "execution_count": 5,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "The total number of elements in the array is given by the attribute <code>size</code>."
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Show the numpy array size\n\nA.size",
            "execution_count": 6,
            "outputs": [
                {
                    "data": {
                        "text/plain": "9"
                    },
                    "execution_count": 6,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<hr>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<h2 id=\"access\">Accessing different elements of a Numpy Array</h2>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We can use rectangular brackets to access the different elements of the array. The correspondence between the rectangular brackets and the list and the rectangular representation is shown in the following figure for a 3x3 array:  "
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoEg.png\" width=\"500\" />"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We can access the 2nd-row 3rd column as shown in the following figure:"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoFT.png\" width=\"400\" />"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": " We simply use the square brackets and the indices corresponding to the element we would like:"
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Access the element on the second row and third column\n\nA[1, 2]",
            "execution_count": 7,
            "outputs": [
                {
                    "data": {
                        "text/plain": "23"
                    },
                    "execution_count": 7,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": " We can also use the following notation to obtain the elements: "
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Access the element on the second row and third column\n\nA[1][2]",
            "execution_count": 8,
            "outputs": [
                {
                    "data": {
                        "text/plain": "23"
                    },
                    "execution_count": 8,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": " Consider the elements shown in the following figure "
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoFF.png\" width=\"400\" />"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We can access the element as follows "
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Access the element on the first row and first column\n\nA[0][0]",
            "execution_count": 9,
            "outputs": [
                {
                    "data": {
                        "text/plain": "11"
                    },
                    "execution_count": 9,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We can also use slicing in numpy arrays. Consider the following figure. We would like to obtain the first two columns in the first row"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoFSF.png\" width=\"400\" />"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": " This can be done with the following syntax "
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Access the element on the first row and first and second columns\n\nA[0][0:2]",
            "execution_count": 10,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([11, 12])"
                    },
                    "execution_count": 10,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "Similarly, we can obtain the first two rows of the 3rd column as follows:"
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Access the element on the first and second rows and third column\n\nA[0:2, 2]",
            "execution_count": 11,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([13, 23])"
                    },
                    "execution_count": 11,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "Corresponding to the following figure: "
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoTST.png\" width=\"400\" />"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<hr>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<h2 id=\"op\">Basic Operations</h2>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We can also add arrays. The process is identical to matrix addition. Matrix addition of <code>X</code> and <code>Y</code> is shown in the following figure:"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoAdd.png\" width=\"500\" />"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "The numpy array is given by <code>X</code> and <code>Y</code>"
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Create a numpy array X\n\nX = np.array([[1, 0], [0, 1]]) \nX",
            "execution_count": 12,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[1, 0],\n       [0, 1]])"
                    },
                    "execution_count": 12,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Create a numpy array Y\n\nY = np.array([[2, 1], [1, 2]]) \nY",
            "execution_count": 13,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[2, 1],\n       [1, 2]])"
                    },
                    "execution_count": 13,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": " We can add the numpy arrays as follows."
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Add X and Y\n\nZ = X + Y\nZ",
            "execution_count": 14,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[3, 1],\n       [1, 3]])"
                    },
                    "execution_count": 14,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "Multiplying a numpy array by a scaler is identical to multiplying a matrix by a scaler. If we multiply the matrix <code>Y</code> by the scaler 2, we simply multiply every element in the matrix by 2 as shown in the figure."
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoDb.png\" width=\"500\" />"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We can perform the same operation in numpy as follows "
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Create a numpy array Y\n\nY = np.array([[2, 1], [1, 2]]) \nY",
            "execution_count": 15,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[2, 1],\n       [1, 2]])"
                    },
                    "execution_count": 15,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Multiply Y with 2\n\nZ = 2 * Y\nZ",
            "execution_count": 16,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[4, 2],\n       [2, 4]])"
                    },
                    "execution_count": 16,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "Multiplication of two arrays corresponds to an element-wise product or Hadamard product. Consider matrix <code>X</code> and <code>Y</code>. The Hadamard product corresponds to multiplying each of the elements in the same position, i.e. multiplying elements contained in the same color boxes together. The result is a new matrix that is the same size as matrix <code>Y</code> or <code>X</code>, as shown in the following figure."
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoMul.png\" width=\"500\" />"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We can perform element-wise product of the array <code>X</code> and <code>Y</code> as follows:"
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Create a numpy array Y\n\nY = np.array([[2, 1], [1, 2]]) \nY",
            "execution_count": 17,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[2, 1],\n       [1, 2]])"
                    },
                    "execution_count": 17,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Create a numpy array X\n\nX = np.array([[1, 0], [0, 1]]) \nX",
            "execution_count": 18,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[1, 0],\n       [0, 1]])"
                    },
                    "execution_count": 18,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Multiply X with Y\n\nZ = X * Y\nZ",
            "execution_count": 19,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[2, 0],\n       [0, 2]])"
                    },
                    "execution_count": 19,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We can also perform matrix multiplication with the numpy arrays <code>A</code> and <code>B</code> as follows:"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "First, we define matrix <code>A</code> and <code>B</code>:"
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Create a matrix A\n\nA = np.array([[0, 1, 1], [1, 0, 1]])\nA",
            "execution_count": 20,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[0, 1, 1],\n       [1, 0, 1]])"
                    },
                    "execution_count": 20,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Create a matrix B\n\nB = np.array([[1, 1], [1, 1], [-1, 1]])\nB",
            "execution_count": 21,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[ 1,  1],\n       [ 1,  1],\n       [-1,  1]])"
                    },
                    "execution_count": 21,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We use the numpy function <code>dot</code> to multiply the arrays together."
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Calculate the dot product\n\nZ = np.dot(A,B)\nZ",
            "execution_count": 22,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[0, 2],\n       [0, 2]])"
                    },
                    "execution_count": 22,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Calculate the sine of Z\n\nnp.sin(Z)",
            "execution_count": 23,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[0.        , 0.90929743],\n       [0.        , 0.90929743]])"
                    },
                    "execution_count": 23,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "We use the numpy attribute <code>T</code> to calculate the transposed matrix"
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Create a matrix C\n\nC = np.array([[1,1],[2,2],[3,3]])\nC",
            "execution_count": 24,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[1, 1],\n       [2, 2],\n       [3, 3]])"
                    },
                    "execution_count": 24,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {
                "jupyter": {
                    "outputs_hidden": false
                }
            },
            "cell_type": "code",
            "source": "# Get the transposed of C\n\nC.T",
            "execution_count": 25,
            "outputs": [
                {
                    "data": {
                        "text/plain": "array([[1, 2, 3],\n       [1, 2, 3]])"
                    },
                    "execution_count": 25,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "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>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n<h2>Get IBM Watson Studio free of charge!</h2>\n    <p><a href=\"https://cocl.us/bottemNotebooksPython101Coursera\"><img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/BottomAd.png\" width=\"750\" align=\"center\"></a></p>\n</div>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "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>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "Other contributors: <a href=\"www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<hr>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "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": {
            "name": "python3",
            "display_name": "Python 3.6",
            "language": "python"
        },
        "language_info": {
            "name": "python",
            "version": "3.6.9",
            "mimetype": "text/x-python",
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "pygments_lexer": "ipython3",
            "nbconvert_exporter": "python",
            "file_extension": ".py"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 4
}