basics/Basics_NumPy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Basics_NumPy",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/BreakoutMentors/Data-Science-and-Machine-Learning/blob/main/basics/Basics_NumPy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "87W6Dnj0bTr7"
      },
      "source": [
        "> Note: Always open in Colab for the best learning experience."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_o89PosdXDAf"
      },
      "source": [
        "# What is NumPy?\n",
        "\n",
        "[NumPy](https://numpy.org/) is a Python package for scientific computing! What that means is that this package is used to do math with arrays. With numpy, you can create arrays because Python does not have built-in arrays. Python does have lists, but if you remember your data structures, lists take up unnecessary space in memory while arrays sizes are static. Also, NumPy does calculations super fast! That is a plus whenever we do math.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fkT8LOS6TLXd"
      },
      "source": [
        "# These are the Basics!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pmpGC4ZRWi1I"
      },
      "source": [
        "# importing NumPy\n",
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qlzBvM83L8es"
      },
      "source": [
        "## Intiializing Arrays from lists and tuples\n",
        "\n",
        "For context, 2-D arrays can also be expressed as matrices in mathematical terminology."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uXWkAHH1sFtJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "affa616e-d41c-401a-ba38-b8570f8c43c9"
      },
      "source": [
        "# Can convert lists into arrays\n",
        "list_a = [1, 2, 3, 4]\n",
        "\n",
        "a = np.array(list_a)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hiCCO5_799Hf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ebd661a6-5f5d-4ddc-fdd7-19cb78b207c6"
      },
      "source": [
        "# Can convert tuples into arrays\n",
        "tup_a = (1, 2, 3, 4)\n",
        "\n",
        "a = np.array(tup_a)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "128w5_VC90vb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7dc99b72-81cd-49bc-ee97-349a41edfd74"
      },
      "source": [
        "# You can also create 2-d arrays using numpy\n",
        "\n",
        "list_2d = [[1, 2, 3, 4],\n",
        "           [5, 6, 7, 8]]\n",
        "\n",
        "array_2d = np.array(list_2d)\n",
        "array_2d"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3, 4],\n",
              "       [5, 6, 7, 8]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m8djCUdbMFL5"
      },
      "source": [
        "## How to view the the dimensions of Arrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZOhz422u-mJY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "abecf7c9-9bef-4863-ad73-62c041a84937"
      },
      "source": [
        "# You can see the shape of the arrays\n",
        "\n",
        "print('(r, w) means r rows and w columns')\n",
        "print('Shape of array_2d:', array_2d.shape)\n",
        "print('Shape of a:', a.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(r, w) means r rows and w columns\n",
            "Shape of array_2d: (2, 4)\n",
            "Shape of a: (4,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yZo635UVMMSL"
      },
      "source": [
        "## Indexing elements from arrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fLXyyOXAU3Hb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "36e5c5fe-ba9f-4457-fb4d-9ca55f6cdbc6"
      },
      "source": [
        "# You can also select elements from arrays:\n",
        "print('All arrays are zero-indexed\\n')\n",
        "a = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "b = np.array([[1, 2, 3, 4, 5],\n",
        "             [6, 7, 8, 9, 10]])\n",
        "\n",
        "print('first element of a:', a[0])\n",
        "print('All elements of a except the first:', a[1:])\n",
        "print('All elements of a except the last:', a[:4])\n",
        "print('All elements between the first and the last:', a[1:-1]) # Equivalent to a[1:4]\n",
        "\n",
        "print('\\nThird element of first row of b:', b[0][3]) # Accesses the 0th row, then the 3rd element of that row\n",
        "print('\\nThird element of first row of b:', b[0, 3]) # Accesses the 0th row and the 3rd column (Equivalent to above)\n",
        "\n",
        "print('Second row of b:', b[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "All arrays are zero-indexed\n",
            "\n",
            "first element of a: 1\n",
            "All elements of a except the first: [2 3 4 5]\n",
            "All elements of a except the last: [1 2 3 4]\n",
            "\n",
            "Third element of first row of b: 4\n",
            "Second row of b: [ 6  7  8  9 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W5TlSO7EMUSs"
      },
      "source": [
        "## Element wise mathematical operations of arrays and matrices"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ljYKb1udAu4f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5334c52a-fc21-46dd-ccd7-5e7594c39dba"
      },
      "source": [
        "# Mathematical Operations with two arrays of the same size!\n",
        "# Must be the same size\n",
        "\n",
        "a = np.array([1, 2, 3, 4, 5])\n",
        "b = np.array([6, 7, 8, 9, 10])\n",
        "\n",
        "print('THIS IS REALLY IMPORTANT!')\n",
        "print('These are all element wise:\\n')\n",
        "print('Adding a+b:', a+b)\n",
        "print('Subtracting a-b:', a-b) #Pretty cool pattern\n",
        "print('Dividing b/a:', b/a)\n",
        "print(\"Multiplying a*b:\", a*b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "THIS IS REALLY IMPORTANT!\n",
            "These are all element wise:\n",
            "\n",
            "Adding a+b: [ 7  9 11 13 15]\n",
            "Subtracting a-b: [-5 -5 -5 -5 -5]\n",
            "Dividing b/a: [6.         3.5        2.66666667 2.25       2.        ]\n",
            "Multiplying a*b: [ 6 14 24 36 50]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LznQz6_NNfk4"
      },
      "source": [
        "To do element-wise mathematical operations with matrices, they matrices need to have the same shape."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4EoYokVENBeJ",
        "outputId": "ffa7ac43-7d03-49b5-91f8-e206affe0698"
      },
      "source": [
        "matrix_a = np.array([[1, 2, 3, 4],\n",
        "                     [5, 6, 7, 8]])\n",
        "\n",
        "matrix_b = np.array([[10, 9, 8, 7],\n",
        "                     [6, 5, 4, 3]])\n",
        "if matrix_a.shape == matrix_b.shape:\n",
        "    print('They both have the same shape!')\n",
        "\n",
        "print('\\nThese are all element wise:\\n')\n",
        "print('Adding a+b:\\n', matrix_a+matrix_b)\n",
        "print('Subtracting a-b:\\n', matrix_a-matrix_b) #Pretty cool pattern\n",
        "print('Dividing b/a:\\n', matrix_b/matrix_a)\n",
        "print(\"Multiplying a*b:\\n\", matrix_a*matrix_b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "They both have the same shape!\n",
            "\n",
            "These are all element wise:\n",
            "\n",
            "Adding a+b:\n",
            " [[11 11 11 11]\n",
            " [11 11 11 11]]\n",
            "Subtracting a-b:\n",
            " [[-9 -7 -5 -3]\n",
            " [-1  1  3  5]]\n",
            "Dividing b/a:\n",
            " [[10.          4.5         2.66666667  1.75      ]\n",
            " [ 1.2         0.83333333  0.57142857  0.375     ]]\n",
            "Multiplying a*b:\n",
            " [[10 18 24 28]\n",
            " [30 30 28 24]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Often, NumPy can also perform these operations on arrays with different size."
      ],
      "metadata": {
        "id": "VKZgFSuVYjAJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "matrix_a = np.array([[1, 2, 3, 4],\n",
        "                     [5, 6, 7, 8]])\n",
        "\n",
        "matrix_b = np.array([[1], [2]])\n",
        "\n",
        "print(\"Matrix a: \")\n",
        "print(matrix_a)\n",
        "print(\"Matrix b: \")\n",
        "print(matrix_b, '\\n')\n",
        "\n",
        "if matrix_a.shape != matrix_b.shape:\n",
        "    print('They don\\'t have the same shape!\\n')\n",
        "\n",
        "\n",
        "print('Adding a+b:\\n', matrix_a+matrix_b)\n",
        "print('Subtracting a-b:\\n', matrix_a-matrix_b)\n",
        "print('Dividing b/a:\\n', matrix_b/matrix_a)\n",
        "print(\"Multiplying a*b:\\n\", matrix_a*matrix_b)"
      ],
      "metadata": {
        "id": "A1i-afdsXcXZ",
        "outputId": "367cd5f6-5fcf-445a-b7a6-0ce205b6ca61",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Matrix a: \n",
            "[[1 2 3 4]\n",
            " [5 6 7 8]]\n",
            "Matrix b: \n",
            "[[1]\n",
            " [2]] \n",
            "\n",
            "They don't have the same shape!\n",
            "\n",
            "Adding a+b:\n",
            " [[ 2  3  4  5]\n",
            " [ 7  8  9 10]]\n",
            "Subtracting a-b:\n",
            " [[0 1 2 3]\n",
            " [3 4 5 6]]\n",
            "Dividing b/a:\n",
            " [[1.         0.5        0.33333333 0.25      ]\n",
            " [0.4        0.33333333 0.28571429 0.25      ]]\n",
            "Multiplying a*b:\n",
            " [[ 1  2  3  4]\n",
            " [10 12 14 16]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2-BtNmgqOufg"
      },
      "source": [
        "## Scalar Mathematical Operations with Arrays and matrices"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7E1wbKkaCxCB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "209f6e9f-4085-429d-b078-e558d1e922f4"
      },
      "source": [
        "# Scaler Mathematical Operations which only uses one array\n",
        "\n",
        "a = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "print('Multiplying 2*a:', 2*a)\n",
        "print('Dividing a/2:', a/2)\n",
        "print('Adding a+2:', a+2)\n",
        "print('Subtracting a-2:', a-2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Multiplying 2*a: [ 2  4  6  8 10]\n",
            "Dividing a/2: [0.5 1.  1.5 2.  2.5]\n",
            "Adding a+2: [3 4 5 6 7]\n",
            "Subtracting a-2: [-1  0  1  2  3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DVMvCACmO1bg",
        "outputId": "f20fe2c9-2502-4a7e-ce2d-c0af5a870531"
      },
      "source": [
        "# Scaler Mathematical Operations with a matrix\n",
        "\n",
        "a = np.array([[1, 2, 3, 4],\n",
        "              [5, 6, 7, 8]])\n",
        "\n",
        "print('Multiplying 2*a:\\n', 2*a)\n",
        "print('Dividing a/2:\\n', a/2)\n",
        "print('Adding a+2:\\n', a+2)\n",
        "print('Subtracting a-2:\\n', a-2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Multiplying 2*a:\n",
            " [[ 2  4  6  8]\n",
            " [10 12 14 16]]\n",
            "Dividing a/2:\n",
            " [[0.5 1.  1.5 2. ]\n",
            " [2.5 3.  3.5 4. ]]\n",
            "Adding a+2:\n",
            " [[ 3  4  5  6]\n",
            " [ 7  8  9 10]]\n",
            "Subtracting a-2:\n",
            " [[-1  0  1  2]\n",
            " [ 3  4  5  6]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zgNnI07iQBL0"
      },
      "source": [
        "## Special Linear Algebra Mathematical Operations\n",
        "\n",
        "Two Linear Algebra mathematical operations will be used frequently in our ML cirriculum:\n",
        "1. Dot-Product of two arrays\n",
        "![dot product](http://media5.datahacker.rs/2020/04/Picture27-1024x386.jpg)\n",
        "2. Matrix Multiplication (PLEASE WATCH GIF)\n",
        "![Matrix Multiplication](https://www.mathwarehouse.com/algebra/matrix/images/matrix-multiplication/how-to-multiply-2-matrices-demo.gif)\n",
        "\n",
        "Something to notice is that there is a pattern to matrix multiplication that will help. For matrix multiplication to happen, the number of columns in matrix A is equal to the number of rows in matrix B for A*B.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tWgcTWmd8JE4",
        "outputId": "4ed05a1b-3c9d-4e6e-be06-9a713f1de57f"
      },
      "source": [
        "# Dot Product\n",
        "a = np.array([2, 7, 1])\n",
        "b = np.array([8, 2, 8])\n",
        "\n",
        "print('Dot product of a and b:', a.dot(b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dot product of a and b: 38\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C8hykPr88dn8",
        "outputId": "e5be414c-312e-4e5b-99b5-c39286539265"
      },
      "source": [
        "# Matrix Multiplication\n",
        "matrix_a = np.array([[1, 4, 6]])\n",
        "\n",
        "matrix_b = np.array([[2, 3],\n",
        "                     [5, 8],\n",
        "                     [7, 9]])\n",
        "\n",
        "print(\"Matrix A:\\n\", matrix_a)\n",
        "print(\"Matrix B:\\n\", matrix_b)\n",
        "\n",
        "print(\"A * B =\", np.matmul(matrix_a, matrix_b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Matrix A:\n",
            " [[1 4 6]]\n",
            "Matrix B:\n",
            " [[2 3]\n",
            " [5 8]\n",
            " [7 9]]\n",
            "A * B = [[64 89]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ILeFLd4yPE_D"
      },
      "source": [
        "## Copying Arrays and Matrices\n",
        "\n",
        "The reason you would do this is to prevent changing an array that is important for you, so having a copy allows you to change it with no worries of impacting the original array or matrix."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7RD_ZUym_tNo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a1c32220-7985-42cf-862c-e8f95a1bf497"
      },
      "source": [
        "# You can copy arrays\n",
        "\n",
        "a = np.array([1, 2, 3, 4, 5])\n",
        "a_copy = a.copy() # This is how you copy\n",
        "print('a_copy:', a_copy)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a_copy: [1 2 3 4 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P50cSFtDPeR4",
        "outputId": "42247a5e-36f9-411c-e3d5-6f007c2eec35"
      },
      "source": [
        "# You can copy matrices\n",
        "\n",
        "a = np.array([[1, 2, 3, 4],\n",
        "              [5, 6, 7, 8]])\n",
        "a_copy = a.copy() # This is how you copy\n",
        "print('a_copy:\\n', a_copy)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a_copy:\n",
            " [[1 2 3 4]\n",
            " [5 6 7 8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pzH3Ed0dPv7i"
      },
      "source": [
        "## Reshaping arrays and matrices"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hS5XnPlsNcwL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39f05dad-bc1f-413f-8faa-8aa711bb8739"
      },
      "source": [
        "# Reshaping arrays\n",
        "\n",
        "# a is a 2d array\n",
        "a = np.array([[1, 2, 3, 4, 5],\n",
        "             [6, 7, 8, 9, 10]])\n",
        "print('a:\\n', a)\n",
        "print('Shape of a:', a.shape)\n",
        "\n",
        "# You can flatten the array into a 1d array\n",
        "flat_a = a.reshape(-1)\n",
        "\n",
        "print('\\nFlattening a...')\n",
        "print('Flat a:', flat_a)\n",
        "print('Shape of flat_a:', flat_a.shape)\n",
        "\n",
        "# You can change a 1d array look like a column\n",
        "col_a = flat_a.reshape(-1, 1)# -1 references to the number of elements in the array\n",
        "\n",
        "print('\\nConverting 1d array flat_a to a column...')\n",
        "print('col_a:\\n', col_a)\n",
        "print('Shape of col_a:', col_a.shape)# A column has r rows and 1 column\n",
        "\n",
        "# You can change a 1d array look like a row\n",
        "row_a = flat_a.reshape(1, -1)\n",
        "\n",
        "print('\\nConverting 1d array flat_a to a row...')\n",
        "print('row_a:\\n', row_a)\n",
        "print('Shape of row_a:', row_a.shape)# A row has 1 row and w columns\n",
        "\n",
        "print('-'*50)\n",
        "print('\\nBOTH row_a AND col_a ARE 2-D ARRAYS!!!!!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a:\n",
            " [[ 1  2  3  4  5]\n",
            " [ 6  7  8  9 10]]\n",
            "Shape of a: (2, 5)\n",
            "\n",
            "Flattening a...\n",
            "Flat a: [ 1  2  3  4  5  6  7  8  9 10]\n",
            "Shape of flat_a: (10,)\n",
            "\n",
            "Converting 1d array flat_a to a column...\n",
            "col_a:\n",
            " [[ 1]\n",
            " [ 2]\n",
            " [ 3]\n",
            " [ 4]\n",
            " [ 5]\n",
            " [ 6]\n",
            " [ 7]\n",
            " [ 8]\n",
            " [ 9]\n",
            " [10]]\n",
            "Shape of col_a: (10, 1)\n",
            "\n",
            "Converting 1d array flat_a to a row...\n",
            "row_a:\n",
            " [[ 1  2  3  4  5  6  7  8  9 10]]\n",
            "Shape of row_a: (1, 10)\n",
            "--------------------------------------------------\n",
            "\n",
            "BOTH row_a AND col_a ARE 2-D ARRAYS!!!!!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Transposing a matrix\n",
        "\n",
        "A matrix is transposed when we swith the order of its dimensions. For a 2D matrix, this looks like a reflection across the diagonal."
      ],
      "metadata": {
        "id": "WHM8oQGJa9JR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.arange(9).reshape(3,3)\n",
        "print(\"Matrix a\")\n",
        "print(a)\n",
        "\n",
        "print(\"\\n Transposed Matrix\")\n",
        "print(a.T) # See np.transpose for more than 2 axes"
      ],
      "metadata": {
        "id": "qJR3i4ora8_F",
        "outputId": "675b6df1-8b50-4cc4-dad4-b0d253037a12",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Matrix a\n",
            "[[0 1 2]\n",
            " [3 4 5]\n",
            " [6 7 8]]\n",
            "\n",
            " Transposed Matrix\n",
            "[[0 3 6]\n",
            " [1 4 7]\n",
            " [2 5 8]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iOwpdgNiSBvt"
      },
      "source": [
        "# Those are the basics!!\n",
        "\n",
        "This NumPy tutorial is good enough for what we will be learning with Data Science and Machine Learning. NumPy is a super fundamental tool for Data Science and I hope that we both master this tool together."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h_ktdAQcSp82"
      },
      "source": [
        "# Test out your own numpy arrays below!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ij0EDWFhR4hb"
      },
      "source": [],
      "execution_count": null,
      "outputs": []
    }
  ]
}