1_numpy_arrays.ipynb

{
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.4",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kaggle": {
      "accelerator": "none",
      "dataSources": [
        {
          "sourceId": 3136,
          "databundleVersionId": 26502,
          "sourceType": "competition"
        }
      ],
      "dockerImageVersionId": 23648,
      "isInternetEnabled": false,
      "language": "python",
      "sourceType": "notebook",
      "isGpuEnabled": false
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat_minor": 0,
  "nbformat": 4,
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Python's built in data structures are great for general-purpose programming, but they lack some specialized features we'd like for data analysis. For example, adding rows or columns of data in an element-wise fashion and performing math operations on two dimensional tables (matrices) are common tasks that aren't readily available with Python's base data types. In this lesson we'll learn about numpy arrays, a data structure available Python's numpy library that implements a variety of useful functions for analyzing data."
      ],
      "metadata": {
        "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
        "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
        "id": "JO2auzHM8Dqi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Numpy Arrays\n"
      ],
      "metadata": {
        "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
        "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
        "trusted": true,
        "id": "Uq0g255D8Dqn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Numpy and Array Basics"
      ],
      "metadata": {
        "id": "os2F20WR8Dqn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The numpy library is one of the core packages in Python's data science software stack. Many other Python data analysis libraries require numpy as a prerequisite, because they use its array data structure as a building block. The Kaggle Python environment has numpy available by default; if you are running Python locally, the Anaconda Python distribution comes with numpy as well.\n",
        "\n",
        "Numpy implements a data structure called the N-dimensional array or ndarray. ndarrays are similar to lists in that they contain a collection of items that can be accessed via indexes. On the other hand, ndarrays are homogeneous, meaning they can only contain objects of the same type and they can be multi-dimensional, making it easy to store 2-dimensional tables or matrices.\n",
        "\n",
        "To work with ndarrays, we need to load the numpy library. It is standard practice to load numpy with the alias \"np\" like so:"
      ],
      "metadata": {
        "id": "2MR49iXL8Dqo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np"
      ],
      "metadata": {
        "trusted": true,
        "id": "as26bPE_8Dqp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The \"as np\" after the import statement lets us access the numpy library's functions using the shorthand \"np.\"\n",
        "\n",
        "Create an ndarray by passing a list to np.array() function:"
      ],
      "metadata": {
        "id": "XUNScjBy8Dqq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list = [1, 2, 3, 4]             # Define a list\n",
        "\n",
        "my_array = np.array(my_list)       # Pass the list to np.array()\n",
        "\n",
        "type(my_array)                     # Check the object's type"
      ],
      "metadata": {
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SrSRQIr68Dqr",
        "outputId": "c25bac4c-08de-458e-cf93-8d949d7f91b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "numpy.ndarray"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To create an array with more than one dimension, pass a nested list to np.array():"
      ],
      "metadata": {
        "id": "oIOt8NOv8Dqt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "second_list = [-1, 6, -7, 8]\n",
        "\n",
        "two_d_array = np.array([my_list, second_list])\n",
        "\n",
        "print(two_d_array)"
      ],
      "metadata": {
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OZeaGvFE8Dqt",
        "outputId": "ffc5215f-b144-491a-bb43-3cf567c55b48"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2  3  4]\n",
            " [-1  6 -7  8]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "An ndarray is defined by the number of dimensions it has, the size of each dimension and the type of data it holds. Check the number and size of dimensions of an ndarray with the shape attribute:"
      ],
      "metadata": {
        "id": "pxPV4uSg8Dqu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "two_d_array.shape"
      ],
      "metadata": {
        "trusted": true,
        "id": "YiwWT72o8Dqu",
        "outputId": "6fd6d508-8bc3-4d89-c1f2-d6f6a85b7c13"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 5,
          "data": {
            "text/plain": "(2, 4)"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The output above shows that this ndarray is 2-dimensional, since there are two values listed, and the dimensions have length 2 and 4. Check the total size (total number of items) in an array with the size attribute:"
      ],
      "metadata": {
        "id": "OwuEMcbw8Dqu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "two_d_array.size"
      ],
      "metadata": {
        "trusted": true,
        "id": "lya3IpZA8Dqu",
        "outputId": "d2e77f85-ca7a-408c-cd99-9ffbb6a956db"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 6,
          "data": {
            "text/plain": "8"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Check the type of the data in an ndarray with the dtype attribute:"
      ],
      "metadata": {
        "id": "jAsA8PYA8Dqv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "two_d_array.dtype"
      ],
      "metadata": {
        "trusted": true,
        "id": "k5QVms2h8Dqv",
        "outputId": "21b7f21a-280c-4af8-ed03-a4d6f2dbd587"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 7,
          "data": {
            "text/plain": "dtype('int64')"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Numpy has a variety of special array creation functions. Some handy array creation functions include:"
      ],
      "metadata": {
        "id": "pLyifg7i8Dqv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# np.identity() to create a square 2d array with 1's across the diagonal\n",
        "\n",
        "np.identity(n = 5)      # Size of the array"
      ],
      "metadata": {
        "trusted": true,
        "id": "h7J2XD5M8Dqv",
        "outputId": "6a597f0c-baf7-481d-d673-8c4e1c30f15f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 8,
          "data": {
            "text/plain": "array([[1., 0., 0., 0., 0.],\n       [0., 1., 0., 0., 0.],\n       [0., 0., 1., 0., 0.],\n       [0., 0., 0., 1., 0.],\n       [0., 0., 0., 0., 1.]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# np.eye() to create a 2d array with 1's across a specified diagonal\n",
        "\n",
        "np.eye(N = 3,  # Number of rows\n",
        "       M = 5,  # Number of columns\n",
        "       k = 1)  # Index of the diagonal (main diagonal (0) is default)"
      ],
      "metadata": {
        "trusted": true,
        "id": "s0CiM4HW8Dqw",
        "outputId": "145b53bb-0380-4eec-8a46-9ce52ca7abd9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 9,
          "data": {
            "text/plain": "array([[0., 1., 0., 0., 0.],\n       [0., 0., 1., 0., 0.],\n       [0., 0., 0., 1., 0.]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# np.ones() to create an array filled with ones:\n",
        "\n",
        "np.ones(shape= [2,4])"
      ],
      "metadata": {
        "trusted": true,
        "id": "VHHIEwRE8Dqw",
        "outputId": "94aad902-46e6-4854-f7e0-ef10b3d1d211"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 10,
          "data": {
            "text/plain": "array([[1., 1., 1., 1.],\n       [1., 1., 1., 1.]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# np.zeros() to create an array filled with zeros:\n",
        "\n",
        "np.zeros(shape= [4,6])"
      ],
      "metadata": {
        "trusted": true,
        "id": "i0_vWK-28Dqw",
        "outputId": "c419e8d5-7167-4f47-e56a-c9472b0f6c80"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 11,
          "data": {
            "text/plain": "array([[0., 0., 0., 0., 0., 0.],\n       [0., 0., 0., 0., 0., 0.],\n       [0., 0., 0., 0., 0., 0.],\n       [0., 0., 0., 0., 0., 0.]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Array Indexing and Slicing"
      ],
      "metadata": {
        "id": "6szGPP6s8Dqw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Numpy ndarrays offer numbered indexing and slicing syntax that mirrors the syntax for Python lists:"
      ],
      "metadata": {
        "id": "wftAWjMB8Dqx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "one_d_array = np.array([1,2,3,4,5,6])\n",
        "\n",
        "one_d_array[3]        # Get the item at index 3"
      ],
      "metadata": {
        "trusted": true,
        "id": "_nECU9kf8Dqx",
        "outputId": "30d00f26-c928-4dc5-df1b-aa83260d9c35"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 14,
          "data": {
            "text/plain": "4"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "one_d_array[3:]       # Get a slice from index 3 to the end"
      ],
      "metadata": {
        "trusted": true,
        "id": "ifL2xny98Dqx",
        "outputId": "76347e48-605e-495d-eadd-18107c46d849"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 15,
          "data": {
            "text/plain": "array([4, 5, 6])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "one_d_array[::-1]     # Slice backwards to reverse the array"
      ],
      "metadata": {
        "trusted": true,
        "id": "wFcBEB7M8Dqx",
        "outputId": "f3f38b2b-c686-44dc-f258-b4ef400169f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 16,
          "data": {
            "text/plain": "array([6, 5, 4, 3, 2, 1])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If an ndarray has more than one dimension, separate indexes for each dimension with a comma:"
      ],
      "metadata": {
        "id": "lD0o8CQB8Dqx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a new 2d array\n",
        "two_d_array = np.array([one_d_array, one_d_array + 6, one_d_array + 12])\n",
        "\n",
        "print(two_d_array)"
      ],
      "metadata": {
        "trusted": true,
        "id": "DWkFbGwo8Dqy",
        "outputId": "8d1fe1fc-e5f0-499c-898d-cff2e31983aa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[[ 1  2  3  4  5  6]\n [ 7  8  9 10 11 12]\n [13 14 15 16 17 18]]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the element at row index 1, column index 4\n",
        "\n",
        "two_d_array[1, 4]"
      ],
      "metadata": {
        "trusted": true,
        "id": "Xiwxw1148Dqy",
        "outputId": "b69c2ea2-a401-4964-a42c-035745429ced"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 18,
          "data": {
            "text/plain": "11"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Slice elements starting at row 2, and column 5\n",
        "\n",
        "two_d_array[1:, 4:]"
      ],
      "metadata": {
        "trusted": true,
        "id": "6anNlcmk8Dqy",
        "outputId": "a092bed7-fc33-40e6-db34-8bc2f8ce7e39"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 19,
          "data": {
            "text/plain": "array([[11, 12],\n       [17, 18]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Reverse both dimensions (180 degree rotation)\n",
        "\n",
        "two_d_array[::-1, ::-1]"
      ],
      "metadata": {
        "trusted": true,
        "id": "nHDnJUcb8Dqy",
        "outputId": "d05ded07-1a3a-4f0a-8fa2-e71e6c5b1d1d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 20,
          "data": {
            "text/plain": "array([[18, 17, 16, 15, 14, 13],\n       [12, 11, 10,  9,  8,  7],\n       [ 6,  5,  4,  3,  2,  1]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Reshaping Arrays"
      ],
      "metadata": {
        "id": "6stVHTFK8Dqy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Numpy has a variety of built in functions to help you manipulate arrays quickly without having to use complicated indexing operations.\n",
        "\n",
        "Reshape an array into a new array with the same data but different structure with np.reshape():"
      ],
      "metadata": {
        "id": "VcuoU7Yx8Dqy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.reshape(a=two_d_array,        # Array to reshape\n",
        "           newshape=(6,3))       # Dimensions of the new array"
      ],
      "metadata": {
        "trusted": true,
        "id": "ptye_03l8Dqz",
        "outputId": "824c63c2-c52c-476c-faa1-fdc666e52fad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 21,
          "data": {
            "text/plain": "array([[ 1,  2,  3],\n       [ 4,  5,  6],\n       [ 7,  8,  9],\n       [10, 11, 12],\n       [13, 14, 15],\n       [16, 17, 18]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Unravel a multi-dimensional into 1 dimension with np.ravel():"
      ],
      "metadata": {
        "id": "XaHe_BXz8Dqz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.ravel(a=two_d_array,\n",
        "         order='C')         # Use C-style unraveling (by rows)"
      ],
      "metadata": {
        "trusted": true,
        "id": "ZM14BFiq8Dqz",
        "outputId": "00e64de0-78db-47a2-9041-d9208a35b158"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 22,
          "data": {
            "text/plain": "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n       18])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.ravel(a=two_d_array,\n",
        "         order='F')         # Use Fortran-style unraveling (by columns)"
      ],
      "metadata": {
        "trusted": true,
        "id": "a1WCntg88Dq0",
        "outputId": "0c3606c7-8572-4835-8412-950e0026e030"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 23,
          "data": {
            "text/plain": "array([ 1,  7, 13,  2,  8, 14,  3,  9, 15,  4, 10, 16,  5, 11, 17,  6, 12,\n       18])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Alternatively, use ndarray.flatten() to flatten a multi-dimensional into 1 dimension and return a copy of the result:"
      ],
      "metadata": {
        "id": "5d9u_LbF8Dq0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "two_d_array.flatten()"
      ],
      "metadata": {
        "trusted": true,
        "id": "FYg9PWxY8Dq0",
        "outputId": "a4123091-157c-4a8e-b55d-b68b6a4a1653"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 24,
          "data": {
            "text/plain": "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n       18])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Get the transpose of an array with ndarray.T:"
      ],
      "metadata": {
        "id": "maqWCWTC8Dq0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "two_d_array.T"
      ],
      "metadata": {
        "trusted": true,
        "id": "ADeH3VaD8Dq5",
        "outputId": "2cab8acc-7dbe-48d5-ce38-39010b77a525"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 25,
          "data": {
            "text/plain": "array([[ 1,  7, 13],\n       [ 2,  8, 14],\n       [ 3,  9, 15],\n       [ 4, 10, 16],\n       [ 5, 11, 17],\n       [ 6, 12, 18]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Flip an array vertically or horizontally with np.flipud() and np.fliplr() respectively:"
      ],
      "metadata": {
        "id": "wZt_Ka7D8Dq5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.flipud(two_d_array)"
      ],
      "metadata": {
        "trusted": true,
        "id": "TB6Hm2by8Dq5",
        "outputId": "2524549b-7a11-41a6-cffb-443ce9c4d30c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 26,
          "data": {
            "text/plain": "array([[13, 14, 15, 16, 17, 18],\n       [ 7,  8,  9, 10, 11, 12],\n       [ 1,  2,  3,  4,  5,  6]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.fliplr(two_d_array)"
      ],
      "metadata": {
        "trusted": true,
        "id": "4DIMDs6b8Dq5",
        "outputId": "013bbf67-9c0f-4abd-cbaa-20677d96f786"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 27,
          "data": {
            "text/plain": "array([[ 6,  5,  4,  3,  2,  1],\n       [12, 11, 10,  9,  8,  7],\n       [18, 17, 16, 15, 14, 13]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Rotate an array 90 degrees counter-clockwise with np.rot90():"
      ],
      "metadata": {
        "id": "xjT0JWQg8Dq6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.rot90(two_d_array,\n",
        "         k=1)             # Number of 90 degree rotations"
      ],
      "metadata": {
        "trusted": true,
        "id": "6Kd4ZpLH8Dq6",
        "outputId": "5eab75b6-ec7f-49ba-cb0f-8e507831f013"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 28,
          "data": {
            "text/plain": "array([[ 6, 12, 18],\n       [ 5, 11, 17],\n       [ 4, 10, 16],\n       [ 3,  9, 15],\n       [ 2,  8, 14],\n       [ 1,  7, 13]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Shift elements in an array along a given dimension with np.roll():"
      ],
      "metadata": {
        "id": "9m_ydu_r8Dq6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.roll(a= two_d_array,\n",
        "        shift = 2,        # Shift elements 2 positions\n",
        "        axis = 1)         # In each row"
      ],
      "metadata": {
        "trusted": true,
        "id": "HBsmUoaL8Dq6",
        "outputId": "ab22071e-bb96-499f-b864-3aa580d1acaa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 29,
          "data": {
            "text/plain": "array([[ 5,  6,  1,  2,  3,  4],\n       [11, 12,  7,  8,  9, 10],\n       [17, 18, 13, 14, 15, 16]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Leave the axis argument empty to shift on a flattened version of the array (shift across all dimensions):"
      ],
      "metadata": {
        "id": "jECUGHWk8Dq6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.roll(a= two_d_array,\n",
        "        shift = 2)"
      ],
      "metadata": {
        "trusted": true,
        "id": "Om7F7r0V8Dq6",
        "outputId": "04de8d43-025c-4f05-8206-96d7639cd29a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 30,
          "data": {
            "text/plain": "array([[17, 18,  1,  2,  3,  4],\n       [ 5,  6,  7,  8,  9, 10],\n       [11, 12, 13, 14, 15, 16]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Join arrays along an axis with np.concatenate():"
      ],
      "metadata": {
        "id": "sXXCsTnY8Dq7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "array_to_join = np.array([[10,20,30],[40,50,60],[70,80,90]])\n",
        "\n",
        "np.concatenate( (two_d_array,array_to_join),  # Arrays to join\n",
        "               axis=1)                        # Axis to join upon"
      ],
      "metadata": {
        "trusted": true,
        "id": "z23CE5GC8Dq7",
        "outputId": "ae0d1253-9910-4528-c35a-94adab1f6b88"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 31,
          "data": {
            "text/plain": "array([[ 1,  2,  3,  4,  5,  6, 10, 20, 30],\n       [ 7,  8,  9, 10, 11, 12, 40, 50, 60],\n       [13, 14, 15, 16, 17, 18, 70, 80, 90]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Array Math Operations"
      ],
      "metadata": {
        "id": "jNRAgbu18Dq7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Creating and manipulating arrays is nice, but the true power of numpy arrays is the ability to perform mathematical operations on many values quickly and easily. Unlike built in Python objects, you can use math operators like +, -, / and * to perform basic math operations with ndarrays:"
      ],
      "metadata": {
        "id": "sT8dRbKh8Dq7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "two_d_array + 100    # Add 100 to each element"
      ],
      "metadata": {
        "trusted": true,
        "id": "OeOQkNBO8Dq7",
        "outputId": "40e88516-b62f-4046-a0e7-f5c5174d3b73"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 32,
          "data": {
            "text/plain": "array([[101, 102, 103, 104, 105, 106],\n       [107, 108, 109, 110, 111, 112],\n       [113, 114, 115, 116, 117, 118]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "two_d_array - 100    # Subtract 100 from each element"
      ],
      "metadata": {
        "trusted": true,
        "id": "1Z3xjXLx8Dq8",
        "outputId": "e6298562-16ef-43c5-9e99-2a87421eaa6e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 33,
          "data": {
            "text/plain": "array([[-99, -98, -97, -96, -95, -94],\n       [-93, -92, -91, -90, -89, -88],\n       [-87, -86, -85, -84, -83, -82]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "two_d_array * 2      # Multiply each element by 2"
      ],
      "metadata": {
        "trusted": true,
        "id": "89C8GvFd8Dq8",
        "outputId": "894e97ab-f128-4496-ea97-66b46fd212dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 34,
          "data": {
            "text/plain": "array([[ 2,  4,  6,  8, 10, 12],\n       [14, 16, 18, 20, 22, 24],\n       [26, 28, 30, 32, 34, 36]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "two_d_array ** 2      # Square each element"
      ],
      "metadata": {
        "trusted": true,
        "id": "jHMTSBI38Dq8",
        "outputId": "6e54a33f-322f-4cb4-a0db-f314e9cacb3d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 35,
          "data": {
            "text/plain": "array([[  1,   4,   9,  16,  25,  36],\n       [ 49,  64,  81, 100, 121, 144],\n       [169, 196, 225, 256, 289, 324]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "two_d_array % 2       # Take modulus of each element"
      ],
      "metadata": {
        "trusted": true,
        "id": "BFn__smW8Dq8",
        "outputId": "a8a98ff6-01a8-42b7-daec-40f8ba623ada"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 36,
          "data": {
            "text/plain": "array([[1, 0, 1, 0, 1, 0],\n       [1, 0, 1, 0, 1, 0],\n       [1, 0, 1, 0, 1, 0]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Beyond operating on each element of an array with a single scalar value, you can also use the basic math operators on two arrays with the same shape. When operating on two arrays, the basic math operators function in an element-wise fashion, returning an array with the same shape as the original:"
      ],
      "metadata": {
        "id": "xexYi5bA8Dq9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "small_array1 = np.array([[1,2],[3,4]])\n",
        "\n",
        "small_array1 + small_array1"
      ],
      "metadata": {
        "trusted": true,
        "id": "EH5QZxqv8Dq9",
        "outputId": "9d6f9149-7f4d-40ec-af0d-1aab850e4c06"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 37,
          "data": {
            "text/plain": "array([[2, 4],\n       [6, 8]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "small_array1 - small_array1"
      ],
      "metadata": {
        "trusted": true,
        "id": "YjU25WQ88Dq9",
        "outputId": "eb580e64-b917-444d-eb68-c7f4847cab92"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 38,
          "data": {
            "text/plain": "array([[0, 0],\n       [0, 0]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "small_array1 * small_array1"
      ],
      "metadata": {
        "trusted": true,
        "id": "aYRzfQ9I8Dq9",
        "outputId": "74aba8d8-b0c0-441e-919e-d7ea67f8d771"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 39,
          "data": {
            "text/plain": "array([[ 1,  4],\n       [ 9, 16]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "small_array1 ** small_array1"
      ],
      "metadata": {
        "trusted": true,
        "id": "dlPuQ4ko8Dq9",
        "outputId": "3e7d562f-f32d-43d4-f802-150706e04422"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 40,
          "data": {
            "text/plain": "array([[  1,   4],\n       [ 27, 256]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Numpy also offers a variety of [named math functions](https://docs.scipy.org/doc/numpy/reference/routines.math.html) for ndarrays. There are too many to cover in detail here, so we'll just look at a selection of some of the most useful ones for data analysis:"
      ],
      "metadata": {
        "id": "O0NaetvU8Dq-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the mean of all the elements in an array with np.mean()\n",
        "\n",
        "np.mean(two_d_array)"
      ],
      "metadata": {
        "trusted": true,
        "id": "XAISrY0T8Dq-",
        "outputId": "7ed25023-bece-4f9b-cd1c-54f96e5f7585"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 41,
          "data": {
            "text/plain": "9.5"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Provide an axis argument to get means across a dimension\n",
        "\n",
        "np.mean(two_d_array,\n",
        "        axis = 1)     # Get means of each row"
      ],
      "metadata": {
        "trusted": true,
        "id": "RPMKvm5L8Dq-",
        "outputId": "4246b59d-d9c8-43d4-ed0a-e05dac0a4c1d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 42,
          "data": {
            "text/plain": "array([ 3.5,  9.5, 15.5])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the standard deviation all the elements in an array with np.std()\n",
        "\n",
        "np.std(two_d_array)"
      ],
      "metadata": {
        "trusted": true,
        "id": "tGBnYvVa8Dq-",
        "outputId": "a9fef25d-5dfa-48d5-9c82-d14d6b32b52b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 43,
          "data": {
            "text/plain": "5.188127472091127"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Provide an axis argument to get standard deviations across a dimension\n",
        "\n",
        "np.std(two_d_array,\n",
        "        axis = 0)     # Get stdev for each column"
      ],
      "metadata": {
        "trusted": true,
        "id": "J3ujYHHE8Dq-",
        "outputId": "29180b3c-29c5-464a-88e8-bfc706b2096b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 44,
          "data": {
            "text/plain": "array([4.89897949, 4.89897949, 4.89897949, 4.89897949, 4.89897949,\n       4.89897949])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Sum the elements of an array across an axis with np.sum()\n",
        "\n",
        "np.sum(two_d_array,\n",
        "       axis=1)        # Get the row sums"
      ],
      "metadata": {
        "trusted": true,
        "id": "u3eSpn8-8Dq_",
        "outputId": "9cea9591-6436-45bf-cc67-4fdf242be2c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 45,
          "data": {
            "text/plain": "array([21, 57, 93])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.sum(two_d_array,\n",
        "       axis=0)        # Get the column sums"
      ],
      "metadata": {
        "trusted": true,
        "id": "KQ32uxoC8Dq_",
        "outputId": "f800effd-c234-4929-85b3-a8fa66560585"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 46,
          "data": {
            "text/plain": "array([21, 24, 27, 30, 33, 36])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Take the log of each element in an array with np.log()\n",
        "\n",
        "np.log(two_d_array)"
      ],
      "metadata": {
        "trusted": true,
        "id": "A63cGzcH8Dq_",
        "outputId": "fab463c1-97b8-4c94-ee35-3d2479927b09"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 47,
          "data": {
            "text/plain": "array([[0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791,\n        1.79175947],\n       [1.94591015, 2.07944154, 2.19722458, 2.30258509, 2.39789527,\n        2.48490665],\n       [2.56494936, 2.63905733, 2.7080502 , 2.77258872, 2.83321334,\n        2.89037176]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Take the square root of each element with np.sqrt()\n",
        "\n",
        "np.sqrt(two_d_array)"
      ],
      "metadata": {
        "trusted": true,
        "id": "hx-sOR9E8Dq_",
        "outputId": "e8f11217-bed9-4902-806f-5c4b990b1520"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 48,
          "data": {
            "text/plain": "array([[1.        , 1.41421356, 1.73205081, 2.        , 2.23606798,\n        2.44948974],\n       [2.64575131, 2.82842712, 3.        , 3.16227766, 3.31662479,\n        3.46410162],\n       [3.60555128, 3.74165739, 3.87298335, 4.        , 4.12310563,\n        4.24264069]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Take the dot product of two arrays with np.dot(). This function performs an element-wise multiply and then a sum for 1-dimensional arrays (vectors) and matrix multiplication for 2-dimensional arrays."
      ],
      "metadata": {
        "id": "fOdRWCiE8Dq_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Take the vector dot product of row 0 and row 1\n",
        "\n",
        "np.dot(two_d_array[0,0:],  # Slice row 0\n",
        "       two_d_array[1,0:])  # Slice row 1"
      ],
      "metadata": {
        "trusted": true,
        "id": "eoSkkeIv8DrA",
        "outputId": "1282b243-34d3-482e-c136-b7547987fc10"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 49,
          "data": {
            "text/plain": "217"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Do a matrix multiply\n",
        "\n",
        "np.dot(small_array1, small_array1)"
      ],
      "metadata": {
        "trusted": true,
        "id": "7G2Lm-DL8DrA",
        "outputId": "033b60c4-bc2c-42c4-cc2d-1f7da1d0f145"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 50,
          "data": {
            "text/plain": "array([[ 7, 10],\n       [15, 22]])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The package includes a variety of more advanced [linear algebra functions](https://docs.scipy.org/doc/numpy/reference/routines.linalg.html) should you need them."
      ],
      "metadata": {
        "id": "EeD49gTR8DrA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## The np.where() Function\n",
        "Although it is important to be able to create your own if/else statements and loops when you need to, numpy's vectorized nature means you can often avoid using such programming constructs. Whenever you want to perform the same operation to each object in a numpy or pandas data structure, there's often a way to do it efficiently without writing your own loops and if statements.\n",
        "\n",
        "For example, imagine you have a sequence of numbers and you want to set all the negative values in the sequence to zero. One way to do it is to use a for loop with an inner if statement:"
      ],
      "metadata": {
        "id": "_xvj58Gv8TT2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Draw 25 random numbers from -1 to 1\n",
        "my_data = np.random.uniform(-1,1,25)\n",
        "\n",
        "\n",
        "for index, number in enumerate(my_data):\n",
        "    if number < 0:\n",
        "        my_data[index] = 0            # Set numbers less than 0 to 0\n",
        "\n",
        "print(my_data)"
      ],
      "metadata": {
        "id": "iAr-my_d8bXO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using a for loop to perform this sort of operation requires writing quite a bit of code and for loops are not particularly fast because they have to operate on each item in a sequence one at a time.\n",
        "\n",
        "Numpy includes a function called where() that lets you perform an if/else check on a sequence with less code:"
      ],
      "metadata": {
        "id": "4dHwcOuy80v1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_data = np.random.uniform(-1,1,25)  # Generate new random numbers\n",
        "\n",
        "my_data = np.where(my_data < 0,       # A logical test\n",
        "                   0,                 # Value to set if the test is true\n",
        "                   my_data)           # Value to set if the test is false\n",
        "\n",
        "print(my_data)\n",
        "print(my_data.shape)\n",
        "\n",
        "two_d_array = np.where(two_d_array < 0, 0, two_d_array)\n",
        "print(two_d_array)\n",
        "print(two_d_array.shape)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3Z2LoJ6J83gk",
        "outputId": "d78fa13f-f809-466b-f22d-7c60fe7c53d4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.         0.         0.15485023 0.         0.43414189 0.25517769\n",
            " 0.31876302 0.536482   0.         0.         0.         0.\n",
            " 0.         0.         0.20534484 0.78886043 0.         0.01991615\n",
            " 0.         0.         0.         0.3462008  0.         0.75594388\n",
            " 0.1599964 ]\n",
            "(25,)\n",
            "[[1 2 3 4]\n",
            " [0 6 0 8]]\n",
            "(2, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Wrap Up"
      ],
      "metadata": {
        "id": "owkha-Qz8DrA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Numpy's ndarray data structure provides many desirable features for working with data, such as element-wise math operations and a variety of functions that work on 2D arrays. Since numpy was built with data analysis in mind, its math operations are optimized for that purpose and are generally faster than what could be achieved if you hand-coded functions to carry out similar operations on lists.\n",
        "\n",
        "Numpy's arrays are great for performing calculations on numerical data, but most data sets you encounter in real life aren't homogeneous. Many data sets include a mixture of data types including numbers, text and dates, so they can't be stored in a single numpy array. In the next lesson we'll conclude our study of Python data structures with Pandas DataFrames, a powerful data container that mirrors the structure of data tables you'd find in databases and spreadsheet programs like Microsoft Excel."
      ],
      "metadata": {
        "id": "Nll-yqYI8DrB"
      }
    }
  ]
}