Numpy_ed_json.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.3"
    },
    "colab": {
      "name": "Numpy_ed.json",
      "provenance": [],
      "collapsed_sections": [
        "u2Pq7LqQTCvo",
        "gQrFeAn1TCvy",
        "WfbE9gxrTCvy",
        "_WQNV94aTCvz",
        "290a4M8gTCv0",
        "07zp2DA2TCv1"
      ],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kwangnam/006697/blob/master/Numpy_ed_json.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RHvVy7j9TCvg"
      },
      "source": [
        "Numpy is the fundamental package for numeric computing with Python. It provides powerful ways to create,\n",
        "store, and/or manipulate data, which makes it able to seamlessly and speedily integrate with a wide variety\n",
        "of databases. This is also the foundation that Pandas is built on, which is a high-performance data-centric\n",
        "package that we will learn later in the course.\n",
        "\n",
        "In this lecture, we will talk about creating array with certain data types, manipulating array, selecting\n",
        "elements from arrays, and loading dataset into array. Such functions are useful for manipulating data and\n",
        "understanding the functionalities of other common Python data packages."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bzOArN9hTCvh"
      },
      "source": [
        "# You'll recall that we import a library using the `import` keyword as numpy's common abbreviation is np\n",
        "import numpy as np\n",
        "import math"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "dRvsZdJ_TCvi"
      },
      "source": [
        "# Array Creation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p4c61YU6TCvi",
        "outputId": "a5e0e3fb-b369-4f40-f489-311b4a29d7fb"
      },
      "source": [
        "# Arrays are displayed as a list or list of lists and can be created through list as well. When creating an\n",
        "# array, we pass in a list as an argument in numpy array\n",
        "a = np.array([1, 2, 3])\n",
        "print(a)\n",
        "# We can print the number of dimensions of a list using the ndim attribute\n",
        "print(a.ndim)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3]\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UQBQmNtHTCvj",
        "outputId": "1fc2d599-8339-4f47-bece-976731151e81"
      },
      "source": [
        "# If we pass in a list of lists in numpy array, we create a multi-dimensional array, for instance, a matrix\n",
        "b = np.array([[1,2,3],[4,5,6]])\n",
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-dtj_hSvTCvk",
        "outputId": "f90f35d9-60f5-4fb5-ac70-92206eb751cf"
      },
      "source": [
        "# We can print out the length of each dimension by calling the shape attribute, which returns a tuple\n",
        "b.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bKyd7w5jTCvk",
        "outputId": "f20648ab-1ac9-418e-ce19-7b12bf99e036"
      },
      "source": [
        "# We can also check the type of items in the array\n",
        "a.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('int64')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sOMTewLZTCvl",
        "outputId": "666cead6-622d-4d64-aa32-afa9470b2b01"
      },
      "source": [
        "# Besides integers, floats are also accepted in numpy arrays\n",
        "c = np.array([2.2, 5, 1.1])\n",
        "c.dtype.name"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'float64'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hUeFJ1v-TCvl",
        "outputId": "7679f1df-2969-451d-e106-d7c34de60172"
      },
      "source": [
        "# Let's look at the data in our array\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2.2, 5. , 1.1])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JM-rwP02TCvm"
      },
      "source": [
        "# Note that numpy automatically converts integers, like 5, up to floats, since there is no loss of prescision.\n",
        "# Numpy will try and give you the best data type format possible to keep your data types homogeneous, which\n",
        "# means all the same, in the array"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A-AxzDtbTCvm",
        "outputId": "5b593d92-f2ca-4f85-9a75-5d2a1b1e1a18"
      },
      "source": [
        "# Sometimes we know the shape of an array that we want to create, but not what we want to be in it. numpy\n",
        "# offers several functions to create arrays with initial placeholders, such as zero's or one's.\n",
        "# Lets create two arrays, both the same shape but with different filler values\n",
        "d = np.zeros((2,3))\n",
        "print(d)\n",
        "\n",
        "e = np.ones((2,3))\n",
        "print(e)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0. 0. 0.]\n",
            " [0. 0. 0.]]\n",
            "[[1. 1. 1.]\n",
            " [1. 1. 1.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8CsJMY83TCvm",
        "outputId": "b7c877c7-c669-493d-fe9a-68e819da4859"
      },
      "source": [
        "# We can also generate an array with random numbers\n",
        "np.random.rand(2,3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.81967966, 0.24861747, 0.1324781 ],\n",
              "       [0.10917913, 0.61025551, 0.87901984]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "itQlvH9ITCvn"
      },
      "source": [
        "# You'll see zeros, ones, and rand used quite often to create example arrays, especially in stack overflow\n",
        "# posts and other forums."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Tds_SedTCvn",
        "outputId": "6a20eb96-d262-43a1-9804-5be3043423b7"
      },
      "source": [
        "# We can also create a sequence of numbers in an array with the arrange() function. The fist argument is the\n",
        "# starting bound and the second argument is the ending bound, and the third argument is the difference between\n",
        "# each consecutive numbers\n",
        "\n",
        "# Let's create an array of every even number from ten (inclusive) to fifty (exclusive)\n",
        "f = np.arange(10, 50, 2)\n",
        "f"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42,\n",
              "       44, 46, 48])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pjXcsgKHTCvo",
        "outputId": "75f0de56-b05b-4951-8171-687ab59d38fc"
      },
      "source": [
        "# if we want to generate a sequence of floats, we can use the linspace() function. In this function the third\n",
        "# argument isn't the difference between two numbers, but the total number of items you want to generate\n",
        "np.linspace( 0, 2, 15 ) # 15 numbers from 0 (inclusive) to 2 (inclusive)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.        , 0.14285714, 0.28571429, 0.42857143, 0.57142857,\n",
              "       0.71428571, 0.85714286, 1.        , 1.14285714, 1.28571429,\n",
              "       1.42857143, 1.57142857, 1.71428571, 1.85714286, 2.        ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u2Pq7LqQTCvo"
      },
      "source": [
        "# Array Operations"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nx9lgf4wTCvp"
      },
      "source": [
        "# We can do many things on arrays, such as mathematical manipulation (addition, subtraction, square,\n",
        "# exponents) as well as use boolean arrays, which are binary values. We can also do matrix manipulation such\n",
        "# as product, transpose, inverse, and so forth."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_76FzTb6TCvp",
        "outputId": "1eaba172-eb83-4e61-e510-f69f42e6be5b"
      },
      "source": [
        "# Arithmetic operators on array apply elementwise.\n",
        "\n",
        "# Let's create a couple of arrays\n",
        "a = np.array([10,20,30,40])\n",
        "b = np.array([1, 2, 3,4])\n",
        "\n",
        "# Now let's look at a minus b\n",
        "c = a-b\n",
        "print(c)\n",
        "\n",
        "# And let's look at a times b\n",
        "d = a*b\n",
        "print(d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 9 18 27 36]\n",
            "[ 10  40  90 160]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mFAh-524TCvp",
        "outputId": "432e7cfb-e50d-4b2e-e022-24f131af1b3c"
      },
      "source": [
        "# With arithmetic manipulation, we can convert current data to the way we want it to be. Here's a real-world\n",
        "# problem I face - I moved down to the United States about 6 years ago from Canada. In Canada we use celcius\n",
        "# for temperatures, and my wife still hasn't converted to the US system which uses farenheit. With numpy I \n",
        "# could easily convert a number of farenheit values, say the weather forecase, to ceclius\n",
        "\n",
        "# Let's create an array of typical Ann Arbor winter farenheit values\n",
        "farenheit = np.array([0,-10,-5,-15,0])\n",
        "\n",
        "# And the formula for conversion is ((°F − 32) × 5/9 = °C)\n",
        "celcius = (farenheit - 31) * (5/9)\n",
        "celcius"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-17.22222222, -22.77777778, -20.        , -25.55555556,\n",
              "       -17.22222222])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CidRQGd5TCvq"
      },
      "source": [
        "# Great, so now she knows it's a little chilly outside but not so bad."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2FpPl8V0TCvq",
        "outputId": "886aa86a-341e-4f19-d374-97b7476e9ebc"
      },
      "source": [
        "# Another useful and important manipulation is the boolean array. We can apply an operator on an array, and a\n",
        "# boolean array will be returned for any element in the original, with True being emitted if it meets the condition and False oetherwise.\n",
        "# For instance, if we want to get a boolean array to check celcius degrees that are greater than -20 degrees\n",
        "celcius > -20"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ True, False, False, False,  True])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7aSw1fO-TCvr",
        "outputId": "0044157d-5099-40f8-c628-189fd6c99e83"
      },
      "source": [
        "# Here's another example, we could use the modulus operator to check numbers in an array to see if they are even. Recall that modulus does division but throws away everything but the remainder (decimal) portion)\n",
        "celcius%2 == 0"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([False, False,  True, False, False])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gmuLSdG2TCvt",
        "outputId": "9bbbbb90-52db-4045-e482-62d911203cd5"
      },
      "source": [
        "# Besides elementwise manipulation, it is important to know that numpy supports matrix manipulation. Let's\n",
        "# look at matrix product. if we want to do elementwise product, we use the \"*\" sign\n",
        "A = np.array([[1,1],[0,1]])\n",
        "B = np.array([[2,0],[3,4]])\n",
        "print(A*B)\n",
        "\n",
        "# if we want to do matrix product, we use the \"@\" sign or use the dot function\n",
        "print(A@B)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[2 0]\n",
            " [0 4]]\n",
            "[[5 4]\n",
            " [3 4]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2eaS4x5bTCvt"
      },
      "source": [
        "# You don't have to worry about complex matrix operations for this course, but it's important to know that\n",
        "# numpy is the underpinning of scientific computing libraries in python, and that it is capable of doing both\n",
        "# element-wise operations (the asterix) as well as matrix-level operations (the @ sign). There's more on this\n",
        "# in a subsequent course."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gV6aC5TPTCvt",
        "outputId": "a13f708d-15a5-4c49-e70e-cc8acc83d73e"
      },
      "source": [
        "# A few more linear algebra concepts are worth layering in here. You might recall that the product of two\n",
        "# matrices is only plausible when the inner dimensions of the two matrices are the same. The dimensions refer\n",
        "# to the number of elements both horizontally and vertically in the rendered matricies you've seen here. We\n",
        "# can use numpy to quickly see the shape of a matrix:\n",
        "A.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_gL_CB6sTCvu",
        "outputId": "f4715c28-4a74-48aa-e49e-beada505bf17"
      },
      "source": [
        "# When manipulating arrays of different types, the type of the resulting array will correspond to \n",
        "# the more general of the two types. This is called upcasting.\n",
        "\n",
        "# Let's create an array of integers\n",
        "array1 = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "print(array1.dtype)\n",
        "\n",
        "# Now let's create an array of floats\n",
        "array2 = np.array([[7.1, 8.2, 9.1], [10.4, 11.2, 12.3]])\n",
        "print(array2.dtype)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "int64\n",
            "float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yOBCRX1wTCvu"
      },
      "source": [
        "# Integers (int) are whole numbers only, and Floating point numbers (float) can have a whole number portion\n",
        "# and a decimal portion. The 64 in this example refers to the number of bits that the operating system is\n",
        "# reserving to represent the number, which determines the size (or precision) of the numbers that can be\n",
        "# represented."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tdwj0SP0TCvu",
        "outputId": "3090f04a-8198-4ede-ff73-c685d0a3fffa"
      },
      "source": [
        "# Let's do an addition for the two arrays\n",
        "array3=array1+array2\n",
        "print(array3)\n",
        "print(array3.dtype)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 8.1 10.2 12.1]\n",
            " [14.4 16.2 18.3]]\n",
            "float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZxLlrvBwTCvv"
      },
      "source": [
        "# Notice how the items in the resulting array have been upcast into floating point numbers"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cw_CneYMTCvv",
        "outputId": "55dd3110-caaa-4a45-90e8-7f7f0bd85208"
      },
      "source": [
        "# Numpy arrays have many interesting aggregation functions on them, such as  sum(), max(), min(), and mean()\n",
        "print(array3.sum())\n",
        "print(array3.max())\n",
        "print(array3.min())\n",
        "print(array3.mean())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "79.3\n",
            "18.3\n",
            "8.1\n",
            "13.216666666666667\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JP99vtIxTCvv",
        "outputId": "27ab88e1-cac5-4f66-a6af-6d237cc3592c"
      },
      "source": [
        "# For two dimensional arrays, we can do the same thing for each row or column\n",
        "# let's create an array with 15 elements, ranging from 1 to 15, \n",
        "# with a dimension of 3X5\n",
        "b = np.arange(1,16,1).reshape(3,5)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4  5]\n",
            " [ 6  7  8  9 10]\n",
            " [11 12 13 14 15]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Bz5RIiQTCvv"
      },
      "source": [
        "# Now, we often think about two dimensional arrays being made up of rows and columns, but you can also think\n",
        "# of these arrays as just a giant ordered list of numbers, and the *shape* of the array, the number of rows\n",
        "# and columns, is just an abstraction that we have for a particular purpose. Actually, this is exactly how\n",
        "# basic images are stored in computer environments.\n",
        "\n",
        "# Let's take a look at an example and see how numpy comes into play."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yquSR0uRTCvw",
        "outputId": "df4afcd9-87c3-40f6-c1a8-a32a884fa2da"
      },
      "source": [
        "# For this demonstration I'll use the python imaging library (PIL) and a function to display images in the\n",
        "# Jupyter notebook\n",
        "from PIL import Image\n",
        "from IPython.display import display\n",
        "\n",
        "# And let's just look at the image I'm talking about\n",
        "im = Image.open('chris.tiff')\n",
        "display(im)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "[Errno 2] No such file or directory: 'chris.tiff'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-32-12896d20ac91>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m# And let's just look at the image I'm talking about\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mim\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'chris.tiff'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mdisplay\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mim\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/PIL/Image.py\u001b[0m in \u001b[0;36mopen\u001b[0;34m(fp, mode)\u001b[0m\n\u001b[1;32m   2768\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2769\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2770\u001b[0;31m         \u001b[0mfp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbuiltins\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"rb\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2771\u001b[0m         \u001b[0mexclusive_fp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2772\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'chris.tiff'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MXhXtpxsTCvw"
      },
      "source": [
        "# Now, we can conver this PIL image to a numpy array\n",
        "array=np.array(im)\n",
        "print(array.shape)\n",
        "array"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZwQkGmKGTCvw"
      },
      "source": [
        "# Here we see that we have a 200x200 array and that the values are all uint8. The uint means that they are\n",
        "# unsigned integers (so no negative numbers) and the 8 means 8 bits per byte. This means that each value can\n",
        "# be up to 2*2*2*2*2*2*2*2=256 in size (well, actually 255, because we start at zero). For black and white\n",
        "# images black is stored as 0 and white is stored as 255. So if we just wanted to invert this image we could\n",
        "# use the numpy array to do so\n",
        "\n",
        "# Let's create an array the same shape\n",
        "mask=np.full(array.shape,255)\n",
        "mask"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tFId-LMhTCvw"
      },
      "source": [
        "# Now let's subtract that from the modified array\n",
        "modified_array=array-mask\n",
        "\n",
        "# And lets convert all of the negative values to positive values\n",
        "modified_array=modified_array*-1\n",
        "\n",
        "# And as a last step, let's tell numpy to set the value of the datatype correctly\n",
        "modified_array=modified_array.astype(np.uint8)\n",
        "modified_array"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "67ENjnAOTCvw"
      },
      "source": [
        "# And lastly, lets display this new array. We do this by using the fromarray() function in the python\n",
        "# imaging library to convert the numpy array into an object jupyter can render\n",
        "display(Image.fromarray(modified_array))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y4IxYc9mTCvx"
      },
      "source": [
        "# Cool. Ok, remember how I started this by talking about how we could just think of this as a giant array\n",
        "# of bytes, and that the shape was an abstraction? Well, we could just decide to reshape the array and still\n",
        "# try and render it. PIL is interpreting the individual rows as lines, so we can change the number of lines\n",
        "# and columns if we want to. What do you think that would look like?\n",
        "reshaped=np.reshape(modified_array,(100,400))\n",
        "print(reshaped.shape)\n",
        "display(Image.fromarray(reshaped))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4s2DF4e9TCvx"
      },
      "source": [
        "# Can't say I find that particularly flattering. By reshaping the array to be only 100 rows high but 400\n",
        "# columns we've essentially doubled the image by taking every other line and stacking them out in width. This\n",
        "# makes the image look more stretched out too.\n",
        "\n",
        "# This isn't an image manipulation course, but the point was to show you that these numpy arrays are really\n",
        "# just abstractions on top of data, and that data has an underlying format (in this case, uint8). But further,\n",
        "# we can build abstractions on top of that, such as computer code which renders a byte as either black or \n",
        "# white, which has meaning to people. In some ways, this whole degree is about data and the abstractions that\n",
        "# we can build on top of that data, from individual byte representations through to complex neural networks of\n",
        "# functions or interactive visualizations. Your role as a data scientist is to understand what the data means\n",
        "# (it's context an collection), and transform it into a different representation to be used for sensemaking."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WNn3fs1lTCvx"
      },
      "source": [
        "# Ok, back to the mechanics of numpy."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gQrFeAn1TCvy"
      },
      "source": [
        "# Indexing, Slicing and Iterating"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VpFSKuJgTCvy"
      },
      "source": [
        "# Indexing, slicing and iterating are extremely important for data manipulation and analysis because these\n",
        "# techinques allow us to select data based on conditions, and copy or update data."
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WfbE9gxrTCvy"
      },
      "source": [
        "## Indexing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 225
        },
        "id": "rxPVlmJOTCvy",
        "outputId": "ecf058bf-8820-40c9-f50b-1e3870888e27"
      },
      "source": [
        "# First we are going to look at integer indexing. A one-dimensional array, works in similar ways as a list -\n",
        "# To get an element in a one-dimensional array, we simply use the offset index.\n",
        "a = np.array([1,3,5,7])\n",
        "a[2]"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-2-af208c87e823>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# First we are going to look at integer indexing. A one-dimensional array, works in similar ways as a list -\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# To get an element in a one-dimensional array, we simply use the offset index.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U1ex7pHKTCvy"
      },
      "source": [
        "# For multidimensional array, we need to use integer array indexing, let's create a new multidimensional array\n",
        "a = np.array([[1,2], [3, 4], [5, 6]])\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xrCrqhi5TCvy"
      },
      "source": [
        "# if we want to select one certain element, we can do so by entering the index, which is comprised of two\n",
        "# integers the first being the row, and the second the column\n",
        "a[1,1] # remember in python we start at 0!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4Miti6hCTCvz"
      },
      "source": [
        "# if we want to get multiple elements \n",
        "# for example, 1, 4, and 6 and put them into a one-dimensional array\n",
        "# we can enter the indices directly into an array function\n",
        "np.array([a[0, 0], a[1, 1], a[2, 1]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3wBJ_g0nTCvz"
      },
      "source": [
        "# we can also do that by using another form of array indexing, which essentiall \"zips\" the first list and the\n",
        "# second list up\n",
        "print(a[[0, 1, 2], [0, 1, 1]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_WQNV94aTCvz"
      },
      "source": [
        "## Boolean Indexing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z6zNF8ItTCvz"
      },
      "source": [
        "# Boolean indexing allows us to select arbitrary elements based on conditions. For example, in the matrix we\n",
        "# just talked about we want to find elements that are greater than 5 so we set up a conditon a >5 \n",
        "print(a >5)\n",
        "# This returns a boolean array showing that if the value at the corresponding index is greater than 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R-XyXFTBTCvz"
      },
      "source": [
        "# We can then place this array of booleans like a mask over the original array to return a one-dimensional \n",
        "# array relating to the true values.\n",
        "print(a[a>5])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TKJFp35vTCv0"
      },
      "source": [
        "# As we will see, this functionality is essential in the pandas toolkit which is the bulk of this course"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "290a4M8gTCv0"
      },
      "source": [
        "## Slicing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rt36gwLYTCv0"
      },
      "source": [
        "# Slicing is a way to create a sub-array based on the original array. For one-dimensional arrays, slicing \n",
        "# works in similar ways to a list. To slice, we use the : sign. For instance, if we put :3 in the indexing\n",
        "# brackets, we get elements from index 0 to index 3 (excluding index 3)\n",
        "a = np.array([0,1,2,3,4,5])\n",
        "print(a[:3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bdwFy2-gTCv0"
      },
      "source": [
        "# By putting 2:4 in the bracket, we get elements from index 2 to index 4 (excluding index 4)\n",
        "print(a[2:4])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tX4QxbD5TCv0"
      },
      "source": [
        "# For multi-dimensional arrays, it works similarly, lets see an example\n",
        "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2TANxrNxTCv1"
      },
      "source": [
        "# First, if we put one argument in the array, for example a[:2] then we would get all the elements from the \n",
        "# first (0th) and second row (1th)\n",
        "a[:2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eS0ZLeYPTCv1"
      },
      "source": [
        "# If we add another argument to the array, for example a[:2, 1:3], we get the first two rows but then the\n",
        "# second and third column values only\n",
        "a[:2, 1:3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1NRXxdJDTCv1"
      },
      "source": [
        "# So, in multidimensional arrays, the first argument is for selecting rows, and the second argument is for \n",
        "# selecting columns"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kBXWWiQuTCv1"
      },
      "source": [
        "# It is important to realize that a slice of an array is a view into the same data. This is called passing by\n",
        "# reference. So modifying the sub array will consequently modify the original array\n",
        "\n",
        "# Here I'll change the element at position [0, 0], which is 2, to 50, then we can see that the value in the\n",
        "# original array is changed to 50 as well\n",
        "\n",
        "sub_array = a[:2, 1:3]\n",
        "print(\"sub array index [0,0] value before change:\", sub_array[0,0])\n",
        "sub_array[0,0] = 50\n",
        "print(\"sub array index [0,0] value after change:\", sub_array[0,0])\n",
        "print(\"original array index [0,1] value after change:\", a[0,1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "07zp2DA2TCv1"
      },
      "source": [
        "# Trying Numpy with Datasets"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5CqUuZVBTCv2"
      },
      "source": [
        "# Now that we have learned the essentials of Numpy let's use it on a couple of datasets"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1ZlqgaNdTCv2"
      },
      "source": [
        "# Here we have a very popular dataset on wine quality, and we are going to only look at red wines. The data\n",
        "# fields include: fixed acidity, volatile aciditycitric acid, residual sugar, chlorides, free sulfur dioxide,\n",
        "# total sulfur dioxidedensity, pH, sulphates, alcohol, quality"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OfCc8TgYTCv2",
        "outputId": "9f47a794-91f6-49d1-e244-9d3e4709d9da"
      },
      "source": [
        "# To load a dataset in Numpy, we can use the genfromtxt() function. We can specify data file name, delimiter\n",
        "# (which is optional but often used), and number of rows to skip if we have a header row, hence it is 1 here\n",
        "\n",
        "# The genfromtxt() function has a parameter called dtype for specifying data types of each column this\n",
        "# parameter is optional. Without specifying the types, all types will be casted the same to the more\n",
        "# general/precise type\n",
        "\n",
        "wines = np.genfromtxt(\"datasets/winequality-red.csv\", delimiter=\";\", skip_header=1)\n",
        "wines"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 7.4  ,  0.7  ,  0.   , ...,  0.56 ,  9.4  ,  5.   ],\n",
              "       [ 7.8  ,  0.88 ,  0.   , ...,  0.68 ,  9.8  ,  5.   ],\n",
              "       [ 7.8  ,  0.76 ,  0.04 , ...,  0.65 ,  9.8  ,  5.   ],\n",
              "       ...,\n",
              "       [ 6.3  ,  0.51 ,  0.13 , ...,  0.75 , 11.   ,  6.   ],\n",
              "       [ 5.9  ,  0.645,  0.12 , ...,  0.71 , 10.2  ,  5.   ],\n",
              "       [ 6.   ,  0.31 ,  0.47 , ...,  0.66 , 11.   ,  6.   ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zb9NnNlwTCv2",
        "outputId": "9267fda6-42ec-4388-962c-6f1ee383ede4"
      },
      "source": [
        "# Recall that we can use integer indexing to get a certain column or a row. For example, if we want to select\n",
        "# the fixed acidity column, which is the first coluumn, we can do so by entering the index into the array.\n",
        "# Also remember that for multidimensional arrays, the first argument refers to the row, and the second\n",
        "# argument refers to the column, and if we just give one argument then we'll get a single dimensional list\n",
        "# back.\n",
        "\n",
        "# So all rows combined but only the first column from them would be\n",
        "print(\"one integer 0 for slicing: \", wines[:, 0])\n",
        "# But if we wanted the same values but wanted to preserve that they sit in their own rows we would write\n",
        "print(\"0 to 1 for slicing: \\n\", wines[:, 0:1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "one integer 0 for slicing:  [7.4 7.8 7.8 ... 6.3 5.9 6. ]\n",
            "0 to 1 for slicing: \n",
            " [[7.4]\n",
            " [7.8]\n",
            " [7.8]\n",
            " ...\n",
            " [6.3]\n",
            " [5.9]\n",
            " [6. ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EMn7FeMsTCv3"
      },
      "source": [
        "# This is another great example of how the shape of the data is an abstraction which we can layer\n",
        "# intentionally on top of the data we are working with."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bDno7MqyTCv3",
        "outputId": "7c4c541a-8b17-4e8c-e1c7-78c7b83980ab"
      },
      "source": [
        "# If we want a range of columns in order, say columns 0 through 3 (recall, this means first, second, and\n",
        "# third, since we start at zero and don't include the training index value), we can do that too\n",
        "wines[:, 0:3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[7.4  , 0.7  , 0.   ],\n",
              "       [7.8  , 0.88 , 0.   ],\n",
              "       [7.8  , 0.76 , 0.04 ],\n",
              "       ...,\n",
              "       [6.3  , 0.51 , 0.13 ],\n",
              "       [5.9  , 0.645, 0.12 ],\n",
              "       [6.   , 0.31 , 0.47 ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4FbncItbTCv3",
        "outputId": "959aba19-81f4-4645-a7c4-b2e809e6fd3a"
      },
      "source": [
        "# What if we want several non-consecutive columns? We can place the indices of the columns that we want into\n",
        "# an array and pass the array as the second argument. Here's an example\n",
        "wines[:, [0,2,4]]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[7.4  , 0.   , 0.076],\n",
              "       [7.8  , 0.   , 0.098],\n",
              "       [7.8  , 0.04 , 0.092],\n",
              "       ...,\n",
              "       [6.3  , 0.13 , 0.076],\n",
              "       [5.9  , 0.12 , 0.075],\n",
              "       [6.   , 0.47 , 0.067]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IFB3NQRPTCv3",
        "outputId": "0cefcc4f-0cb3-43af-cfc7-5f937880772c"
      },
      "source": [
        "# We can also do some basic summarization of this dataset. For example, if we want to find out the average\n",
        "# quality of red wine, we can select the quality column. We could do this in a couple of ways, but the most\n",
        "# appropriate is to use the -1 value for the index, as negative numbers mean slicing from the back of the\n",
        "# list. We can then call the aggregation functions on this data.\n",
        "wines[:,-1].mean()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.6360225140712945"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q502_UfbTCv4"
      },
      "source": [
        "# Let's take a look at another dataset, this time on graduate school admissions. It has fields such as GRE\n",
        "# score, TOEFL score, university rating, GPA, having research experience or not, and a chance of admission.\n",
        "# With this dataset, we can do data manipulation and basic analysis to infer what conditions are associated\n",
        "# with higher chance of admission. Let's take a look."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iH0hZWxqTCv4",
        "outputId": "4981f54c-da52-4a12-cd03-1a00d12e79af"
      },
      "source": [
        "# We can specify data field names when using genfromtxt() to loads CSV data. Also, we can have numpy try and\n",
        "# infer the type of a column by setting the dtype parameter to None\n",
        "graduate_admission = np.genfromtxt('datasets/Admission_Predict.csv', dtype=None, delimiter=',', skip_header=1,\n",
        "                                   names=('Serial No','GRE Score', 'TOEFL Score', 'University Rating', 'SOP',\n",
        "                                          'LOR','CGPA','Research', 'Chance of Admit'))\n",
        "graduate_admission"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([(  1, 337, 118, 4, 4.5, 4.5, 9.65, 1, 0.92),\n",
              "       (  2, 324, 107, 4, 4. , 4.5, 8.87, 1, 0.76),\n",
              "       (  3, 316, 104, 3, 3. , 3.5, 8.  , 1, 0.72),\n",
              "       (  4, 322, 110, 3, 3.5, 2.5, 8.67, 1, 0.8 ),\n",
              "       (  5, 314, 103, 2, 2. , 3. , 8.21, 0, 0.65),\n",
              "       (  6, 330, 115, 5, 4.5, 3. , 9.34, 1, 0.9 ),\n",
              "       (  7, 321, 109, 3, 3. , 4. , 8.2 , 1, 0.75),\n",
              "       (  8, 308, 101, 2, 3. , 4. , 7.9 , 0, 0.68),\n",
              "       (  9, 302, 102, 1, 2. , 1.5, 8.  , 0, 0.5 ),\n",
              "       ( 10, 323, 108, 3, 3.5, 3. , 8.6 , 0, 0.45),\n",
              "       ( 11, 325, 106, 3, 3.5, 4. , 8.4 , 1, 0.52),\n",
              "       ( 12, 327, 111, 4, 4. , 4.5, 9.  , 1, 0.84),\n",
              "       ( 13, 328, 112, 4, 4. , 4.5, 9.1 , 1, 0.78),\n",
              "       ( 14, 307, 109, 3, 4. , 3. , 8.  , 1, 0.62),\n",
              "       ( 15, 311, 104, 3, 3.5, 2. , 8.2 , 1, 0.61),\n",
              "       ( 16, 314, 105, 3, 3.5, 2.5, 8.3 , 0, 0.54),\n",
              "       ( 17, 317, 107, 3, 4. , 3. , 8.7 , 0, 0.66),\n",
              "       ( 18, 319, 106, 3, 4. , 3. , 8.  , 1, 0.65),\n",
              "       ( 19, 318, 110, 3, 4. , 3. , 8.8 , 0, 0.63),\n",
              "       ( 20, 303, 102, 3, 3.5, 3. , 8.5 , 0, 0.62),\n",
              "       ( 21, 312, 107, 3, 3. , 2. , 7.9 , 1, 0.64),\n",
              "       ( 22, 325, 114, 4, 3. , 2. , 8.4 , 0, 0.7 ),\n",
              "       ( 23, 328, 116, 5, 5. , 5. , 9.5 , 1, 0.94),\n",
              "       ( 24, 334, 119, 5, 5. , 4.5, 9.7 , 1, 0.95),\n",
              "       ( 25, 336, 119, 5, 4. , 3.5, 9.8 , 1, 0.97),\n",
              "       ( 26, 340, 120, 5, 4.5, 4.5, 9.6 , 1, 0.94),\n",
              "       ( 27, 322, 109, 5, 4.5, 3.5, 8.8 , 0, 0.76),\n",
              "       ( 28, 298,  98, 2, 1.5, 2.5, 7.5 , 1, 0.44),\n",
              "       ( 29, 295,  93, 1, 2. , 2. , 7.2 , 0, 0.46),\n",
              "       ( 30, 310,  99, 2, 1.5, 2. , 7.3 , 0, 0.54),\n",
              "       ( 31, 300,  97, 2, 3. , 3. , 8.1 , 1, 0.65),\n",
              "       ( 32, 327, 103, 3, 4. , 4. , 8.3 , 1, 0.74),\n",
              "       ( 33, 338, 118, 4, 3. , 4.5, 9.4 , 1, 0.91),\n",
              "       ( 34, 340, 114, 5, 4. , 4. , 9.6 , 1, 0.9 ),\n",
              "       ( 35, 331, 112, 5, 4. , 5. , 9.8 , 1, 0.94),\n",
              "       ( 36, 320, 110, 5, 5. , 5. , 9.2 , 1, 0.88),\n",
              "       ( 37, 299, 106, 2, 4. , 4. , 8.4 , 0, 0.64),\n",
              "       ( 38, 300, 105, 1, 1. , 2. , 7.8 , 0, 0.58),\n",
              "       ( 39, 304, 105, 1, 3. , 1.5, 7.5 , 0, 0.52),\n",
              "       ( 40, 307, 108, 2, 4. , 3.5, 7.7 , 0, 0.48),\n",
              "       ( 41, 308, 110, 3, 3.5, 3. , 8.  , 1, 0.46),\n",
              "       ( 42, 316, 105, 2, 2.5, 2.5, 8.2 , 1, 0.49),\n",
              "       ( 43, 313, 107, 2, 2.5, 2. , 8.5 , 1, 0.53),\n",
              "       ( 44, 332, 117, 4, 4.5, 4. , 9.1 , 0, 0.87),\n",
              "       ( 45, 326, 113, 5, 4.5, 4. , 9.4 , 1, 0.91),\n",
              "       ( 46, 322, 110, 5, 5. , 4. , 9.1 , 1, 0.88),\n",
              "       ( 47, 329, 114, 5, 4. , 5. , 9.3 , 1, 0.86),\n",
              "       ( 48, 339, 119, 5, 4.5, 4. , 9.7 , 0, 0.89),\n",
              "       ( 49, 321, 110, 3, 3.5, 5. , 8.85, 1, 0.82),\n",
              "       ( 50, 327, 111, 4, 3. , 4. , 8.4 , 1, 0.78),\n",
              "       ( 51, 313,  98, 3, 2.5, 4.5, 8.3 , 1, 0.76),\n",
              "       ( 52, 312, 100, 2, 1.5, 3.5, 7.9 , 1, 0.56),\n",
              "       ( 53, 334, 116, 4, 4. , 3. , 8.  , 1, 0.78),\n",
              "       ( 54, 324, 112, 4, 4. , 2.5, 8.1 , 1, 0.72),\n",
              "       ( 55, 322, 110, 3, 3. , 3.5, 8.  , 0, 0.7 ),\n",
              "       ( 56, 320, 103, 3, 3. , 3. , 7.7 , 0, 0.64),\n",
              "       ( 57, 316, 102, 3, 2. , 3. , 7.4 , 0, 0.64),\n",
              "       ( 58, 298,  99, 2, 4. , 2. , 7.6 , 0, 0.46),\n",
              "       ( 59, 300,  99, 1, 3. , 2. , 6.8 , 1, 0.36),\n",
              "       ( 60, 311, 104, 2, 2. , 2. , 8.3 , 0, 0.42),\n",
              "       ( 61, 309, 100, 2, 3. , 3. , 8.1 , 0, 0.48),\n",
              "       ( 62, 307, 101, 3, 4. , 3. , 8.2 , 0, 0.47),\n",
              "       ( 63, 304, 105, 2, 3. , 3. , 8.2 , 1, 0.54),\n",
              "       ( 64, 315, 107, 2, 4. , 3. , 8.5 , 1, 0.56),\n",
              "       ( 65, 325, 111, 3, 3. , 3.5, 8.7 , 0, 0.52),\n",
              "       ( 66, 325, 112, 4, 3.5, 3.5, 8.92, 0, 0.55),\n",
              "       ( 67, 327, 114, 3, 3. , 3. , 9.02, 0, 0.61),\n",
              "       ( 68, 316, 107, 2, 3.5, 3.5, 8.64, 1, 0.57),\n",
              "       ( 69, 318, 109, 3, 3.5, 4. , 9.22, 1, 0.68),\n",
              "       ( 70, 328, 115, 4, 4.5, 4. , 9.16, 1, 0.78),\n",
              "       ( 71, 332, 118, 5, 5. , 5. , 9.64, 1, 0.94),\n",
              "       ( 72, 336, 112, 5, 5. , 5. , 9.76, 1, 0.96),\n",
              "       ( 73, 321, 111, 5, 5. , 5. , 9.45, 1, 0.93),\n",
              "       ( 74, 314, 108, 4, 4.5, 4. , 9.04, 1, 0.84),\n",
              "       ( 75, 314, 106, 3, 3. , 5. , 8.9 , 0, 0.74),\n",
              "       ( 76, 329, 114, 2, 2. , 4. , 8.56, 1, 0.72),\n",
              "       ( 77, 327, 112, 3, 3. , 3. , 8.72, 1, 0.74),\n",
              "       ( 78, 301,  99, 2, 3. , 2. , 8.22, 0, 0.64),\n",
              "       ( 79, 296,  95, 2, 3. , 2. , 7.54, 1, 0.44),\n",
              "       ( 80, 294,  93, 1, 1.5, 2. , 7.36, 0, 0.46),\n",
              "       ( 81, 312, 105, 3, 2. , 3. , 8.02, 1, 0.5 ),\n",
              "       ( 82, 340, 120, 4, 5. , 5. , 9.5 , 1, 0.96),\n",
              "       ( 83, 320, 110, 5, 5. , 4.5, 9.22, 1, 0.92),\n",
              "       ( 84, 322, 115, 5, 4. , 4.5, 9.36, 1, 0.92),\n",
              "       ( 85, 340, 115, 5, 4.5, 4.5, 9.45, 1, 0.94),\n",
              "       ( 86, 319, 103, 4, 4.5, 3.5, 8.66, 0, 0.76),\n",
              "       ( 87, 315, 106, 3, 4.5, 3.5, 8.42, 0, 0.72),\n",
              "       ( 88, 317, 107, 2, 3.5, 3. , 8.28, 0, 0.66),\n",
              "       ( 89, 314, 108, 3, 4.5, 3.5, 8.14, 0, 0.64),\n",
              "       ( 90, 316, 109, 4, 4.5, 3.5, 8.76, 1, 0.74),\n",
              "       ( 91, 318, 106, 2, 4. , 4. , 7.92, 1, 0.64),\n",
              "       ( 92, 299,  97, 3, 5. , 3.5, 7.66, 0, 0.38),\n",
              "       ( 93, 298,  98, 2, 4. , 3. , 8.03, 0, 0.34),\n",
              "       ( 94, 301,  97, 2, 3. , 3. , 7.88, 1, 0.44),\n",
              "       ( 95, 303,  99, 3, 2. , 2.5, 7.66, 0, 0.36),\n",
              "       ( 96, 304, 100, 4, 1.5, 2.5, 7.84, 0, 0.42),\n",
              "       ( 97, 306, 100, 2, 3. , 3. , 8.  , 0, 0.48),\n",
              "       ( 98, 331, 120, 3, 4. , 4. , 8.96, 1, 0.86),\n",
              "       ( 99, 332, 119, 4, 5. , 4.5, 9.24, 1, 0.9 ),\n",
              "       (100, 323, 113, 3, 4. , 4. , 8.88, 1, 0.79),\n",
              "       (101, 322, 107, 3, 3.5, 3.5, 8.46, 1, 0.71),\n",
              "       (102, 312, 105, 2, 2.5, 3. , 8.12, 0, 0.64),\n",
              "       (103, 314, 106, 2, 4. , 3.5, 8.25, 0, 0.62),\n",
              "       (104, 317, 104, 2, 4.5, 4. , 8.47, 0, 0.57),\n",
              "       (105, 326, 112, 3, 3.5, 3. , 9.05, 1, 0.74),\n",
              "       (106, 316, 110, 3, 4. , 4.5, 8.78, 1, 0.69),\n",
              "       (107, 329, 111, 4, 4.5, 4.5, 9.18, 1, 0.87),\n",
              "       (108, 338, 117, 4, 3.5, 4.5, 9.46, 1, 0.91),\n",
              "       (109, 331, 116, 5, 5. , 5. , 9.38, 1, 0.93),\n",
              "       (110, 304, 103, 5, 5. , 4. , 8.64, 0, 0.68),\n",
              "       (111, 305, 108, 5, 3. , 3. , 8.48, 0, 0.61),\n",
              "       (112, 321, 109, 4, 4. , 4. , 8.68, 1, 0.69),\n",
              "       (113, 301, 107, 3, 3.5, 3.5, 8.34, 1, 0.62),\n",
              "       (114, 320, 110, 2, 4. , 3.5, 8.56, 0, 0.72),\n",
              "       (115, 311, 105, 3, 3.5, 3. , 8.45, 1, 0.59),\n",
              "       (116, 310, 106, 4, 4.5, 4.5, 9.04, 1, 0.66),\n",
              "       (117, 299, 102, 3, 4. , 3.5, 8.62, 0, 0.56),\n",
              "       (118, 290, 104, 4, 2. , 2.5, 7.46, 0, 0.45),\n",
              "       (119, 296,  99, 2, 3. , 3.5, 7.28, 0, 0.47),\n",
              "       (120, 327, 104, 5, 3. , 3.5, 8.84, 1, 0.71),\n",
              "       (121, 335, 117, 5, 5. , 5. , 9.56, 1, 0.94),\n",
              "       (122, 334, 119, 5, 4.5, 4.5, 9.48, 1, 0.94),\n",
              "       (123, 310, 106, 4, 1.5, 2.5, 8.36, 0, 0.57),\n",
              "       (124, 308, 108, 3, 3.5, 3.5, 8.22, 0, 0.61),\n",
              "       (125, 301, 106, 4, 2.5, 3. , 8.47, 0, 0.57),\n",
              "       (126, 300, 100, 3, 2. , 3. , 8.66, 1, 0.64),\n",
              "       (127, 323, 113, 3, 4. , 3. , 9.32, 1, 0.85),\n",
              "       (128, 319, 112, 3, 2.5, 2. , 8.71, 1, 0.78),\n",
              "       (129, 326, 112, 3, 3.5, 3. , 9.1 , 1, 0.84),\n",
              "       (130, 333, 118, 5, 5. , 5. , 9.35, 1, 0.92),\n",
              "       (131, 339, 114, 5, 4. , 4.5, 9.76, 1, 0.96),\n",
              "       (132, 303, 105, 5, 5. , 4.5, 8.65, 0, 0.77),\n",
              "       (133, 309, 105, 5, 3.5, 3.5, 8.56, 0, 0.71),\n",
              "       (134, 323, 112, 5, 4. , 4.5, 8.78, 0, 0.79),\n",
              "       (135, 333, 113, 5, 4. , 4. , 9.28, 1, 0.89),\n",
              "       (136, 314, 109, 4, 3.5, 4. , 8.77, 1, 0.82),\n",
              "       (137, 312, 103, 3, 5. , 4. , 8.45, 0, 0.76),\n",
              "       (138, 316, 100, 2, 1.5, 3. , 8.16, 1, 0.71),\n",
              "       (139, 326, 116, 2, 4.5, 3. , 9.08, 1, 0.8 ),\n",
              "       (140, 318, 109, 1, 3.5, 3.5, 9.12, 0, 0.78),\n",
              "       (141, 329, 110, 2, 4. , 3. , 9.15, 1, 0.84),\n",
              "       (142, 332, 118, 2, 4.5, 3.5, 9.36, 1, 0.9 ),\n",
              "       (143, 331, 115, 5, 4. , 3.5, 9.44, 1, 0.92),\n",
              "       (144, 340, 120, 4, 4.5, 4. , 9.92, 1, 0.97),\n",
              "       (145, 325, 112, 2, 3. , 3.5, 8.96, 1, 0.8 ),\n",
              "       (146, 320, 113, 2, 2. , 2.5, 8.64, 1, 0.81),\n",
              "       (147, 315, 105, 3, 2. , 2.5, 8.48, 0, 0.75),\n",
              "       (148, 326, 114, 3, 3. , 3. , 9.11, 1, 0.83),\n",
              "       (149, 339, 116, 4, 4. , 3.5, 9.8 , 1, 0.96),\n",
              "       (150, 311, 106, 2, 3.5, 3. , 8.26, 1, 0.79),\n",
              "       (151, 334, 114, 4, 4. , 4. , 9.43, 1, 0.93),\n",
              "       (152, 332, 116, 5, 5. , 5. , 9.28, 1, 0.94),\n",
              "       (153, 321, 112, 5, 5. , 5. , 9.06, 1, 0.86),\n",
              "       (154, 324, 105, 3, 3. , 4. , 8.75, 0, 0.79),\n",
              "       (155, 326, 108, 3, 3. , 3.5, 8.89, 0, 0.8 ),\n",
              "       (156, 312, 109, 3, 3. , 3. , 8.69, 0, 0.77),\n",
              "       (157, 315, 105, 3, 2. , 2.5, 8.34, 0, 0.7 ),\n",
              "       (158, 309, 104, 2, 2. , 2.5, 8.26, 0, 0.65),\n",
              "       (159, 306, 106, 2, 2. , 2.5, 8.14, 0, 0.61),\n",
              "       (160, 297, 100, 1, 1.5, 2. , 7.9 , 0, 0.52),\n",
              "       (161, 315, 103, 1, 1.5, 2. , 7.86, 0, 0.57),\n",
              "       (162, 298,  99, 1, 1.5, 3. , 7.46, 0, 0.53),\n",
              "       (163, 318, 109, 3, 3. , 3. , 8.5 , 0, 0.67),\n",
              "       (164, 317, 105, 3, 3.5, 3. , 8.56, 0, 0.68),\n",
              "       (165, 329, 111, 4, 4.5, 4. , 9.01, 1, 0.81),\n",
              "       (166, 322, 110, 5, 4.5, 4. , 8.97, 0, 0.78),\n",
              "       (167, 302, 102, 3, 3.5, 5. , 8.33, 0, 0.65),\n",
              "       (168, 313, 102, 3, 2. , 3. , 8.27, 0, 0.64),\n",
              "       (169, 293,  97, 2, 2. , 4. , 7.8 , 1, 0.64),\n",
              "       (170, 311,  99, 2, 2.5, 3. , 7.98, 0, 0.65),\n",
              "       (171, 312, 101, 2, 2.5, 3.5, 8.04, 1, 0.68),\n",
              "       (172, 334, 117, 5, 4. , 4.5, 9.07, 1, 0.89),\n",
              "       (173, 322, 110, 4, 4. , 5. , 9.13, 1, 0.86),\n",
              "       (174, 323, 113, 4, 4. , 4.5, 9.23, 1, 0.89),\n",
              "       (175, 321, 111, 4, 4. , 4. , 8.97, 1, 0.87),\n",
              "       (176, 320, 111, 4, 4.5, 3.5, 8.87, 1, 0.85),\n",
              "       (177, 329, 119, 4, 4.5, 4.5, 9.16, 1, 0.9 ),\n",
              "       (178, 319, 110, 3, 3.5, 3.5, 9.04, 0, 0.82),\n",
              "       (179, 309, 108, 3, 2.5, 3. , 8.12, 0, 0.72),\n",
              "       (180, 307, 102, 3, 3. , 3. , 8.27, 0, 0.73),\n",
              "       (181, 300, 104, 3, 3.5, 3. , 8.16, 0, 0.71),\n",
              "       (182, 305, 107, 2, 2.5, 2.5, 8.42, 0, 0.71),\n",
              "       (183, 299, 100, 2, 3. , 3.5, 7.88, 0, 0.68),\n",
              "       (184, 314, 110, 3, 4. , 4. , 8.8 , 0, 0.75),\n",
              "       (185, 316, 106, 2, 2.5, 4. , 8.32, 0, 0.72),\n",
              "       (186, 327, 113, 4, 4.5, 4.5, 9.11, 1, 0.89),\n",
              "       (187, 317, 107, 3, 3.5, 3. , 8.68, 1, 0.84),\n",
              "       (188, 335, 118, 5, 4.5, 3.5, 9.44, 1, 0.93),\n",
              "       (189, 331, 115, 5, 4.5, 3.5, 9.36, 1, 0.93),\n",
              "       (190, 324, 112, 5, 5. , 5. , 9.08, 1, 0.88),\n",
              "       (191, 324, 111, 5, 4.5, 4. , 9.16, 1, 0.9 ),\n",
              "       (192, 323, 110, 5, 4. , 5. , 8.98, 1, 0.87),\n",
              "       (193, 322, 114, 5, 4.5, 4. , 8.94, 1, 0.86),\n",
              "       (194, 336, 118, 5, 4.5, 5. , 9.53, 1, 0.94),\n",
              "       (195, 316, 109, 3, 3.5, 3. , 8.76, 0, 0.77),\n",
              "       (196, 307, 107, 2, 3. , 3.5, 8.52, 1, 0.78),\n",
              "       (197, 306, 105, 2, 3. , 2.5, 8.26, 0, 0.73),\n",
              "       (198, 310, 106, 2, 3.5, 2.5, 8.33, 0, 0.73),\n",
              "       (199, 311, 104, 3, 4.5, 4.5, 8.43, 0, 0.7 ),\n",
              "       (200, 313, 107, 3, 4. , 4.5, 8.69, 0, 0.72),\n",
              "       (201, 317, 103, 3, 2.5, 3. , 8.54, 1, 0.73),\n",
              "       (202, 315, 110, 2, 3.5, 3. , 8.46, 1, 0.72),\n",
              "       (203, 340, 120, 5, 4.5, 4.5, 9.91, 1, 0.97),\n",
              "       (204, 334, 120, 5, 4. , 5. , 9.87, 1, 0.97),\n",
              "       (205, 298, 105, 3, 3.5, 4. , 8.54, 0, 0.69),\n",
              "       (206, 295,  99, 2, 2.5, 3. , 7.65, 0, 0.57),\n",
              "       (207, 315,  99, 2, 3.5, 3. , 7.89, 0, 0.63),\n",
              "       (208, 310, 102, 3, 3.5, 4. , 8.02, 1, 0.66),\n",
              "       (209, 305, 106, 2, 3. , 3. , 8.16, 0, 0.64),\n",
              "       (210, 301, 104, 3, 3.5, 4. , 8.12, 1, 0.68),\n",
              "       (211, 325, 108, 4, 4.5, 4. , 9.06, 1, 0.79),\n",
              "       (212, 328, 110, 4, 5. , 4. , 9.14, 1, 0.82),\n",
              "       (213, 338, 120, 4, 5. , 5. , 9.66, 1, 0.95),\n",
              "       (214, 333, 119, 5, 5. , 4.5, 9.78, 1, 0.96),\n",
              "       (215, 331, 117, 4, 4.5, 5. , 9.42, 1, 0.94),\n",
              "       (216, 330, 116, 5, 5. , 4.5, 9.36, 1, 0.93),\n",
              "       (217, 322, 112, 4, 4.5, 4.5, 9.26, 1, 0.91),\n",
              "       (218, 321, 109, 4, 4. , 4. , 9.13, 1, 0.85),\n",
              "       (219, 324, 110, 4, 3. , 3.5, 8.97, 1, 0.84),\n",
              "       (220, 312, 104, 3, 3.5, 3.5, 8.42, 0, 0.74),\n",
              "       (221, 313, 103, 3, 4. , 4. , 8.75, 0, 0.76),\n",
              "       (222, 316, 110, 3, 3.5, 4. , 8.56, 0, 0.75),\n",
              "       (223, 324, 113, 4, 4.5, 4. , 8.79, 0, 0.76),\n",
              "       (224, 308, 109, 2, 3. , 4. , 8.45, 0, 0.71),\n",
              "       (225, 305, 105, 2, 3. , 2. , 8.23, 0, 0.67),\n",
              "       (226, 296,  99, 2, 2.5, 2.5, 8.03, 0, 0.61),\n",
              "       (227, 306, 110, 2, 3.5, 4. , 8.45, 0, 0.63),\n",
              "       (228, 312, 110, 2, 3.5, 3. , 8.53, 0, 0.64),\n",
              "       (229, 318, 112, 3, 4. , 3.5, 8.67, 0, 0.71),\n",
              "       (230, 324, 111, 4, 3. , 3. , 9.01, 1, 0.82),\n",
              "       (231, 313, 104, 3, 4. , 4.5, 8.65, 0, 0.73),\n",
              "       (232, 319, 106, 3, 3.5, 2.5, 8.33, 1, 0.74),\n",
              "       (233, 312, 107, 2, 2.5, 3.5, 8.27, 0, 0.69),\n",
              "       (234, 304, 100, 2, 2.5, 3.5, 8.07, 0, 0.64),\n",
              "       (235, 330, 113, 5, 5. , 4. , 9.31, 1, 0.91),\n",
              "       (236, 326, 111, 5, 4.5, 4. , 9.23, 1, 0.88),\n",
              "       (237, 325, 112, 4, 4. , 4.5, 9.17, 1, 0.85),\n",
              "       (238, 329, 114, 5, 4.5, 5. , 9.19, 1, 0.86),\n",
              "       (239, 310, 104, 3, 2. , 3.5, 8.37, 0, 0.7 ),\n",
              "       (240, 299, 100, 1, 1.5, 2. , 7.89, 0, 0.59),\n",
              "       (241, 296, 101, 1, 2.5, 3. , 7.68, 0, 0.6 ),\n",
              "       (242, 317, 103, 2, 2.5, 2. , 8.15, 0, 0.65),\n",
              "       (243, 324, 115, 3, 3.5, 3. , 8.76, 1, 0.7 ),\n",
              "       (244, 325, 114, 3, 3.5, 3. , 9.04, 1, 0.76),\n",
              "       (245, 314, 107, 2, 2.5, 4. , 8.56, 0, 0.63),\n",
              "       (246, 328, 110, 4, 4. , 2.5, 9.02, 1, 0.81),\n",
              "       (247, 316, 105, 3, 3. , 3.5, 8.73, 0, 0.72),\n",
              "       (248, 311, 104, 2, 2.5, 3.5, 8.48, 0, 0.71),\n",
              "       (249, 324, 110, 3, 3.5, 4. , 8.87, 1, 0.8 ),\n",
              "       (250, 321, 111, 3, 3.5, 4. , 8.83, 1, 0.77),\n",
              "       (251, 320, 104, 3, 3. , 2.5, 8.57, 1, 0.74),\n",
              "       (252, 316,  99, 2, 2.5, 3. , 9.  , 0, 0.7 ),\n",
              "       (253, 318, 100, 2, 2.5, 3.5, 8.54, 1, 0.71),\n",
              "       (254, 335, 115, 4, 4.5, 4.5, 9.68, 1, 0.93),\n",
              "       (255, 321, 114, 4, 4. , 5. , 9.12, 0, 0.85),\n",
              "       (256, 307, 110, 4, 4. , 4.5, 8.37, 0, 0.79),\n",
              "       (257, 309,  99, 3, 4. , 4. , 8.56, 0, 0.76),\n",
              "       (258, 324, 100, 3, 4. , 5. , 8.64, 1, 0.78),\n",
              "       (259, 326, 102, 4, 5. , 5. , 8.76, 1, 0.77),\n",
              "       (260, 331, 119, 4, 5. , 4.5, 9.34, 1, 0.9 ),\n",
              "       (261, 327, 108, 5, 5. , 3.5, 9.13, 1, 0.87),\n",
              "       (262, 312, 104, 3, 3.5, 4. , 8.09, 0, 0.71),\n",
              "       (263, 308, 103, 2, 2.5, 4. , 8.36, 1, 0.7 ),\n",
              "       (264, 324, 111, 3, 2.5, 1.5, 8.79, 1, 0.7 ),\n",
              "       (265, 325, 110, 2, 3. , 2.5, 8.76, 1, 0.75),\n",
              "       (266, 313, 102, 3, 2.5, 2.5, 8.68, 0, 0.71),\n",
              "       (267, 312, 105, 2, 2. , 2.5, 8.45, 0, 0.72),\n",
              "       (268, 314, 107, 3, 3. , 3.5, 8.17, 1, 0.73),\n",
              "       (269, 327, 113, 4, 4.5, 5. , 9.14, 0, 0.83),\n",
              "       (270, 308, 108, 4, 4.5, 5. , 8.34, 0, 0.77),\n",
              "       (271, 306, 105, 2, 2.5, 3. , 8.22, 1, 0.72),\n",
              "       (272, 299,  96, 2, 1.5, 2. , 7.86, 0, 0.54),\n",
              "       (273, 294,  95, 1, 1.5, 1.5, 7.64, 0, 0.49),\n",
              "       (274, 312,  99, 1, 1. , 1.5, 8.01, 1, 0.52),\n",
              "       (275, 315, 100, 1, 2. , 2.5, 7.95, 0, 0.58),\n",
              "       (276, 322, 110, 3, 3.5, 3. , 8.96, 1, 0.78),\n",
              "       (277, 329, 113, 5, 5. , 4.5, 9.45, 1, 0.89),\n",
              "       (278, 320, 101, 2, 2.5, 3. , 8.62, 0, 0.7 ),\n",
              "       (279, 308, 103, 2, 3. , 3.5, 8.49, 0, 0.66),\n",
              "       (280, 304, 102, 2, 3. , 4. , 8.73, 0, 0.67),\n",
              "       (281, 311, 102, 3, 4.5, 4. , 8.64, 1, 0.68),\n",
              "       (282, 317, 110, 3, 4. , 4.5, 9.11, 1, 0.8 ),\n",
              "       (283, 312, 106, 3, 4. , 3.5, 8.79, 1, 0.81),\n",
              "       (284, 321, 111, 3, 2.5, 3. , 8.9 , 1, 0.8 ),\n",
              "       (285, 340, 112, 4, 5. , 4.5, 9.66, 1, 0.94),\n",
              "       (286, 331, 116, 5, 4. , 4. , 9.26, 1, 0.93),\n",
              "       (287, 336, 118, 5, 4.5, 4. , 9.19, 1, 0.92),\n",
              "       (288, 324, 114, 5, 5. , 4.5, 9.08, 1, 0.89),\n",
              "       (289, 314, 104, 4, 5. , 5. , 9.02, 0, 0.82),\n",
              "       (290, 313, 109, 3, 4. , 3.5, 9.  , 0, 0.79),\n",
              "       (291, 307, 105, 2, 2.5, 3. , 7.65, 0, 0.58),\n",
              "       (292, 300, 102, 2, 1.5, 2. , 7.87, 0, 0.56),\n",
              "       (293, 302,  99, 2, 1. , 2. , 7.97, 0, 0.56),\n",
              "       (294, 312,  98, 1, 3.5, 3. , 8.18, 1, 0.64),\n",
              "       (295, 316, 101, 2, 2.5, 2. , 8.32, 1, 0.61),\n",
              "       (296, 317, 100, 2, 3. , 2.5, 8.57, 0, 0.68),\n",
              "       (297, 310, 107, 3, 3.5, 3.5, 8.67, 0, 0.76),\n",
              "       (298, 320, 120, 3, 4. , 4.5, 9.11, 0, 0.86),\n",
              "       (299, 330, 114, 3, 4.5, 4.5, 9.24, 1, 0.9 ),\n",
              "       (300, 305, 112, 3, 3. , 3.5, 8.65, 0, 0.71),\n",
              "       (301, 309, 106, 2, 2.5, 2.5, 8.  , 0, 0.62),\n",
              "       (302, 319, 108, 2, 2.5, 3. , 8.76, 0, 0.66),\n",
              "       (303, 322, 105, 2, 3. , 3. , 8.45, 1, 0.65),\n",
              "       (304, 323, 107, 3, 3.5, 3.5, 8.55, 1, 0.73),\n",
              "       (305, 313, 106, 2, 2.5, 2. , 8.43, 0, 0.62),\n",
              "       (306, 321, 109, 3, 3.5, 3.5, 8.8 , 1, 0.74),\n",
              "       (307, 323, 110, 3, 4. , 3.5, 9.1 , 1, 0.79),\n",
              "       (308, 325, 112, 4, 4. , 4. , 9.  , 1, 0.8 ),\n",
              "       (309, 312, 108, 3, 3.5, 3. , 8.53, 0, 0.69),\n",
              "       (310, 308, 110, 4, 3.5, 3. , 8.6 , 0, 0.7 ),\n",
              "       (311, 320, 104, 3, 3. , 3.5, 8.74, 1, 0.76),\n",
              "       (312, 328, 108, 4, 4.5, 4. , 9.18, 1, 0.84),\n",
              "       (313, 311, 107, 4, 4.5, 4.5, 9.  , 1, 0.78),\n",
              "       (314, 301, 100, 3, 3.5, 3. , 8.04, 0, 0.67),\n",
              "       (315, 305, 105, 2, 3. , 4. , 8.13, 0, 0.66),\n",
              "       (316, 308, 104, 2, 2.5, 3. , 8.07, 0, 0.65),\n",
              "       (317, 298, 101, 2, 1.5, 2. , 7.86, 0, 0.54),\n",
              "       (318, 300,  99, 1, 1. , 2.5, 8.01, 0, 0.58),\n",
              "       (319, 324, 111, 3, 2.5, 2. , 8.8 , 1, 0.79),\n",
              "       (320, 327, 113, 4, 3.5, 3. , 8.69, 1, 0.8 ),\n",
              "       (321, 317, 106, 3, 4. , 3.5, 8.5 , 1, 0.75),\n",
              "       (322, 323, 104, 3, 4. , 4. , 8.44, 1, 0.73),\n",
              "       (323, 314, 107, 2, 2.5, 4. , 8.27, 0, 0.72),\n",
              "       (324, 305, 102, 2, 2. , 2.5, 8.18, 0, 0.62),\n",
              "       (325, 315, 104, 3, 3. , 2.5, 8.33, 0, 0.67),\n",
              "       (326, 326, 116, 3, 3.5, 4. , 9.14, 1, 0.81),\n",
              "       (327, 299, 100, 3, 2. , 2. , 8.02, 0, 0.63),\n",
              "       (328, 295, 101, 2, 2.5, 2. , 7.86, 0, 0.69),\n",
              "       (329, 324, 112, 4, 4. , 3.5, 8.77, 1, 0.8 ),\n",
              "       (330, 297,  96, 2, 2.5, 1.5, 7.89, 0, 0.43),\n",
              "       (331, 327, 113, 3, 3.5, 3. , 8.66, 1, 0.8 ),\n",
              "       (332, 311, 105, 2, 3. , 2. , 8.12, 1, 0.73),\n",
              "       (333, 308, 106, 3, 3.5, 2.5, 8.21, 1, 0.75),\n",
              "       (334, 319, 108, 3, 3. , 3.5, 8.54, 1, 0.71),\n",
              "       (335, 312, 107, 4, 4.5, 4. , 8.65, 1, 0.73),\n",
              "       (336, 325, 111, 4, 4. , 4.5, 9.11, 1, 0.83),\n",
              "       (337, 319, 110, 3, 3. , 2.5, 8.79, 0, 0.72),\n",
              "       (338, 332, 118, 5, 5. , 5. , 9.47, 1, 0.94),\n",
              "       (339, 323, 108, 5, 4. , 4. , 8.74, 1, 0.81),\n",
              "       (340, 324, 107, 5, 3.5, 4. , 8.66, 1, 0.81),\n",
              "       (341, 312, 107, 3, 3. , 3. , 8.46, 1, 0.75),\n",
              "       (342, 326, 110, 3, 3.5, 3.5, 8.76, 1, 0.79),\n",
              "       (343, 308, 106, 3, 3. , 3. , 8.24, 0, 0.58),\n",
              "       (344, 305, 103, 2, 2.5, 3.5, 8.13, 0, 0.59),\n",
              "       (345, 295,  96, 2, 1.5, 2. , 7.34, 0, 0.47),\n",
              "       (346, 316,  98, 1, 1.5, 2. , 7.43, 0, 0.49),\n",
              "       (347, 304,  97, 2, 1.5, 2. , 7.64, 0, 0.47),\n",
              "       (348, 299,  94, 1, 1. , 1. , 7.34, 0, 0.42),\n",
              "       (349, 302,  99, 1, 2. , 2. , 7.25, 0, 0.57),\n",
              "       (350, 313, 101, 3, 2.5, 3. , 8.04, 0, 0.62),\n",
              "       (351, 318, 107, 3, 3. , 3.5, 8.27, 1, 0.74),\n",
              "       (352, 325, 110, 4, 3.5, 4. , 8.67, 1, 0.73),\n",
              "       (353, 303, 100, 2, 3. , 3.5, 8.06, 1, 0.64),\n",
              "       (354, 300, 102, 3, 3.5, 2.5, 8.17, 0, 0.63),\n",
              "       (355, 297,  98, 2, 2.5, 3. , 7.67, 0, 0.59),\n",
              "       (356, 317, 106, 2, 2. , 3.5, 8.12, 0, 0.73),\n",
              "       (357, 327, 109, 3, 3.5, 4. , 8.77, 1, 0.79),\n",
              "       (358, 301, 104, 2, 3.5, 3.5, 7.89, 1, 0.68),\n",
              "       (359, 314, 105, 2, 2.5, 2. , 7.64, 0, 0.7 ),\n",
              "       (360, 321, 107, 2, 2. , 1.5, 8.44, 0, 0.81),\n",
              "       (361, 322, 110, 3, 4. , 5. , 8.64, 1, 0.85),\n",
              "       (362, 334, 116, 4, 4. , 3.5, 9.54, 1, 0.93),\n",
              "       (363, 338, 115, 5, 4.5, 5. , 9.23, 1, 0.91),\n",
              "       (364, 306, 103, 2, 2.5, 3. , 8.36, 0, 0.69),\n",
              "       (365, 313, 102, 3, 3.5, 4. , 8.9 , 1, 0.77),\n",
              "       (366, 330, 114, 4, 4.5, 3. , 9.17, 1, 0.86),\n",
              "       (367, 320, 104, 3, 3.5, 4.5, 8.34, 1, 0.74),\n",
              "       (368, 311,  98, 1, 1. , 2.5, 7.46, 0, 0.57),\n",
              "       (369, 298,  92, 1, 2. , 2. , 7.88, 0, 0.51),\n",
              "       (370, 301,  98, 1, 2. , 3. , 8.03, 1, 0.67),\n",
              "       (371, 310, 103, 2, 2.5, 2.5, 8.24, 0, 0.72),\n",
              "       (372, 324, 110, 3, 3.5, 3. , 9.22, 1, 0.89),\n",
              "       (373, 336, 119, 4, 4.5, 4. , 9.62, 1, 0.95),\n",
              "       (374, 321, 109, 3, 3. , 3. , 8.54, 1, 0.79),\n",
              "       (375, 315, 105, 2, 2. , 2.5, 7.65, 0, 0.39),\n",
              "       (376, 304, 101, 2, 2. , 2.5, 7.66, 0, 0.38),\n",
              "       (377, 297,  96, 2, 2.5, 2. , 7.43, 0, 0.34),\n",
              "       (378, 290, 100, 1, 1.5, 2. , 7.56, 0, 0.47),\n",
              "       (379, 303,  98, 1, 2. , 2.5, 7.65, 0, 0.56),\n",
              "       (380, 311,  99, 1, 2.5, 3. , 8.43, 1, 0.71),\n",
              "       (381, 322, 104, 3, 3.5, 4. , 8.84, 1, 0.78),\n",
              "       (382, 319, 105, 3, 3. , 3.5, 8.67, 1, 0.73),\n",
              "       (383, 324, 110, 4, 4.5, 4. , 9.15, 1, 0.82),\n",
              "       (384, 300, 100, 3, 3. , 3.5, 8.26, 0, 0.62),\n",
              "       (385, 340, 113, 4, 5. , 5. , 9.74, 1, 0.96),\n",
              "       (386, 335, 117, 5, 5. , 5. , 9.82, 1, 0.96),\n",
              "       (387, 302, 101, 2, 2.5, 3.5, 7.96, 0, 0.46),\n",
              "       (388, 307, 105, 2, 2. , 3.5, 8.1 , 0, 0.53),\n",
              "       (389, 296,  97, 2, 1.5, 2. , 7.8 , 0, 0.49),\n",
              "       (390, 320, 108, 3, 3.5, 4. , 8.44, 1, 0.76),\n",
              "       (391, 314, 102, 2, 2. , 2.5, 8.24, 0, 0.64),\n",
              "       (392, 318, 106, 3, 2. , 3. , 8.65, 0, 0.71),\n",
              "       (393, 326, 112, 4, 4. , 3.5, 9.12, 1, 0.84),\n",
              "       (394, 317, 104, 2, 3. , 3. , 8.76, 0, 0.77),\n",
              "       (395, 329, 111, 4, 4.5, 4. , 9.23, 1, 0.89),\n",
              "       (396, 324, 110, 3, 3.5, 3.5, 9.04, 1, 0.82),\n",
              "       (397, 325, 107, 3, 3. , 3.5, 9.11, 1, 0.84),\n",
              "       (398, 330, 116, 4, 5. , 4.5, 9.45, 1, 0.91),\n",
              "       (399, 312, 103, 3, 3.5, 4. , 8.78, 0, 0.67),\n",
              "       (400, 333, 117, 4, 5. , 4. , 9.66, 1, 0.95)],\n",
              "      dtype=[('Serial_No', '<i8'), ('GRE_Score', '<i8'), ('TOEFL_Score', '<i8'), ('University_Rating', '<i8'), ('SOP', '<f8'), ('LOR', '<f8'), ('CGPA', '<f8'), ('Research', '<i8'), ('Chance_of_Admit', '<f8')])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C3fVrnxnTCv4",
        "outputId": "33d66bb1-7e1f-4137-a7fd-37aee346af9c"
      },
      "source": [
        "# Notice that the resulting array is actually a one-dimensional array with 400 tuples\n",
        "graduate_admission.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(400,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J_8qUPXSTCv4",
        "outputId": "916d7d44-c971-4c5a-c2b5-666d6ca1cf6d"
      },
      "source": [
        "# We can retrieve a column from the array using the column's name for example, let's get the CGPA column and\n",
        "# only the first five values.\n",
        "graduate_admission['CGPA'][0:5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([9.65, 8.87, 8.  , 8.67, 8.21])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c-5Y_RMxTCv4",
        "outputId": "afc2dc46-3ae0-4cb0-b7ff-8ff22d16e3f6"
      },
      "source": [
        "# Since the GPA in the dataset range from 1 to 10, and in the US it's more common to use a scale of up to 4,\n",
        "# a common task might be to convert the GPA by dividing by 10 and then multiplying by 4\n",
        "graduate_admission['CGPA'] = graduate_admission['CGPA'] /10 *4\n",
        "graduate_admission['CGPA'][0:20] #let's get 20 values"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3.86 , 3.548, 3.2  , 3.468, 3.284, 3.736, 3.28 , 3.16 , 3.2  ,\n",
              "       3.44 , 3.36 , 3.6  , 3.64 , 3.2  , 3.28 , 3.32 , 3.48 , 3.2  ,\n",
              "       3.52 , 3.4  ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SFzbX697TCv5",
        "outputId": "db202c5c-1b8a-4cda-ab7c-69c41bb9acba"
      },
      "source": [
        "# Recall boolean masking. We can use this to find out how many students have had research experience by\n",
        "# creating a boolean mask and passing it to the array indexing operator\n",
        "len(graduate_admission[graduate_admission['Research'] == 1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "219"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TN5M9zcNTCv5",
        "outputId": "15904c8f-c14c-4ab0-e503-8b3bf24cb0e0"
      },
      "source": [
        "# Since we have the data field chance of admission, which ranges from 0 to 1, we can try to see if students\n",
        "# with high chance of admission (>0.8) on average have higher GRE score than those with lower chance of\n",
        "# admission (<0.4)\n",
        "\n",
        "# So first we use boolean masking to pull out only those students we are interested in based on their chance\n",
        "# of admission, then we pull out only their GPA scores, then we print the mean values.\n",
        "print(graduate_admission[graduate_admission['Chance_of_Admit'] > 0.8]['GRE_Score'].mean())\n",
        "print(graduate_admission[graduate_admission['Chance_of_Admit'] < 0.4]['GRE_Score'].mean())\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "328.7350427350427\n",
            "302.2857142857143\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GvNxKEuRTCv5",
        "outputId": "7ee69cb6-262f-405d-8169-d31bb022b02e"
      },
      "source": [
        "# Take a moment to reflect here, do you understand what is happening in these calls?\n",
        "\n",
        "# When we do the boolean masking we are left with an array with tuples in it still, and numpy holds underneath\n",
        "# this a list of the columns we specified and their name and indexes\n",
        "graduate_admission[graduate_admission['Chance_of_Admit'] > 0.8]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([(  1, 337, 118, 4, 4.5, 4.5, 3.86 , 1, 0.92),\n",
              "       (  6, 330, 115, 5, 4.5, 3. , 3.736, 1, 0.9 ),\n",
              "       ( 12, 327, 111, 4, 4. , 4.5, 3.6  , 1, 0.84),\n",
              "       ( 23, 328, 116, 5, 5. , 5. , 3.8  , 1, 0.94),\n",
              "       ( 24, 334, 119, 5, 5. , 4.5, 3.88 , 1, 0.95),\n",
              "       ( 25, 336, 119, 5, 4. , 3.5, 3.92 , 1, 0.97),\n",
              "       ( 26, 340, 120, 5, 4.5, 4.5, 3.84 , 1, 0.94),\n",
              "       ( 33, 338, 118, 4, 3. , 4.5, 3.76 , 1, 0.91),\n",
              "       ( 34, 340, 114, 5, 4. , 4. , 3.84 , 1, 0.9 ),\n",
              "       ( 35, 331, 112, 5, 4. , 5. , 3.92 , 1, 0.94),\n",
              "       ( 36, 320, 110, 5, 5. , 5. , 3.68 , 1, 0.88),\n",
              "       ( 44, 332, 117, 4, 4.5, 4. , 3.64 , 0, 0.87),\n",
              "       ( 45, 326, 113, 5, 4.5, 4. , 3.76 , 1, 0.91),\n",
              "       ( 46, 322, 110, 5, 5. , 4. , 3.64 , 1, 0.88),\n",
              "       ( 47, 329, 114, 5, 4. , 5. , 3.72 , 1, 0.86),\n",
              "       ( 48, 339, 119, 5, 4.5, 4. , 3.88 , 0, 0.89),\n",
              "       ( 49, 321, 110, 3, 3.5, 5. , 3.54 , 1, 0.82),\n",
              "       ( 71, 332, 118, 5, 5. , 5. , 3.856, 1, 0.94),\n",
              "       ( 72, 336, 112, 5, 5. , 5. , 3.904, 1, 0.96),\n",
              "       ( 73, 321, 111, 5, 5. , 5. , 3.78 , 1, 0.93),\n",
              "       ( 74, 314, 108, 4, 4.5, 4. , 3.616, 1, 0.84),\n",
              "       ( 82, 340, 120, 4, 5. , 5. , 3.8  , 1, 0.96),\n",
              "       ( 83, 320, 110, 5, 5. , 4.5, 3.688, 1, 0.92),\n",
              "       ( 84, 322, 115, 5, 4. , 4.5, 3.744, 1, 0.92),\n",
              "       ( 85, 340, 115, 5, 4.5, 4.5, 3.78 , 1, 0.94),\n",
              "       ( 98, 331, 120, 3, 4. , 4. , 3.584, 1, 0.86),\n",
              "       ( 99, 332, 119, 4, 5. , 4.5, 3.696, 1, 0.9 ),\n",
              "       (107, 329, 111, 4, 4.5, 4.5, 3.672, 1, 0.87),\n",
              "       (108, 338, 117, 4, 3.5, 4.5, 3.784, 1, 0.91),\n",
              "       (109, 331, 116, 5, 5. , 5. , 3.752, 1, 0.93),\n",
              "       (121, 335, 117, 5, 5. , 5. , 3.824, 1, 0.94),\n",
              "       (122, 334, 119, 5, 4.5, 4.5, 3.792, 1, 0.94),\n",
              "       (127, 323, 113, 3, 4. , 3. , 3.728, 1, 0.85),\n",
              "       (129, 326, 112, 3, 3.5, 3. , 3.64 , 1, 0.84),\n",
              "       (130, 333, 118, 5, 5. , 5. , 3.74 , 1, 0.92),\n",
              "       (131, 339, 114, 5, 4. , 4.5, 3.904, 1, 0.96),\n",
              "       (135, 333, 113, 5, 4. , 4. , 3.712, 1, 0.89),\n",
              "       (136, 314, 109, 4, 3.5, 4. , 3.508, 1, 0.82),\n",
              "       (141, 329, 110, 2, 4. , 3. , 3.66 , 1, 0.84),\n",
              "       (142, 332, 118, 2, 4.5, 3.5, 3.744, 1, 0.9 ),\n",
              "       (143, 331, 115, 5, 4. , 3.5, 3.776, 1, 0.92),\n",
              "       (144, 340, 120, 4, 4.5, 4. , 3.968, 1, 0.97),\n",
              "       (146, 320, 113, 2, 2. , 2.5, 3.456, 1, 0.81),\n",
              "       (148, 326, 114, 3, 3. , 3. , 3.644, 1, 0.83),\n",
              "       (149, 339, 116, 4, 4. , 3.5, 3.92 , 1, 0.96),\n",
              "       (151, 334, 114, 4, 4. , 4. , 3.772, 1, 0.93),\n",
              "       (152, 332, 116, 5, 5. , 5. , 3.712, 1, 0.94),\n",
              "       (153, 321, 112, 5, 5. , 5. , 3.624, 1, 0.86),\n",
              "       (165, 329, 111, 4, 4.5, 4. , 3.604, 1, 0.81),\n",
              "       (172, 334, 117, 5, 4. , 4.5, 3.628, 1, 0.89),\n",
              "       (173, 322, 110, 4, 4. , 5. , 3.652, 1, 0.86),\n",
              "       (174, 323, 113, 4, 4. , 4.5, 3.692, 1, 0.89),\n",
              "       (175, 321, 111, 4, 4. , 4. , 3.588, 1, 0.87),\n",
              "       (176, 320, 111, 4, 4.5, 3.5, 3.548, 1, 0.85),\n",
              "       (177, 329, 119, 4, 4.5, 4.5, 3.664, 1, 0.9 ),\n",
              "       (178, 319, 110, 3, 3.5, 3.5, 3.616, 0, 0.82),\n",
              "       (186, 327, 113, 4, 4.5, 4.5, 3.644, 1, 0.89),\n",
              "       (187, 317, 107, 3, 3.5, 3. , 3.472, 1, 0.84),\n",
              "       (188, 335, 118, 5, 4.5, 3.5, 3.776, 1, 0.93),\n",
              "       (189, 331, 115, 5, 4.5, 3.5, 3.744, 1, 0.93),\n",
              "       (190, 324, 112, 5, 5. , 5. , 3.632, 1, 0.88),\n",
              "       (191, 324, 111, 5, 4.5, 4. , 3.664, 1, 0.9 ),\n",
              "       (192, 323, 110, 5, 4. , 5. , 3.592, 1, 0.87),\n",
              "       (193, 322, 114, 5, 4.5, 4. , 3.576, 1, 0.86),\n",
              "       (194, 336, 118, 5, 4.5, 5. , 3.812, 1, 0.94),\n",
              "       (203, 340, 120, 5, 4.5, 4.5, 3.964, 1, 0.97),\n",
              "       (204, 334, 120, 5, 4. , 5. , 3.948, 1, 0.97),\n",
              "       (212, 328, 110, 4, 5. , 4. , 3.656, 1, 0.82),\n",
              "       (213, 338, 120, 4, 5. , 5. , 3.864, 1, 0.95),\n",
              "       (214, 333, 119, 5, 5. , 4.5, 3.912, 1, 0.96),\n",
              "       (215, 331, 117, 4, 4.5, 5. , 3.768, 1, 0.94),\n",
              "       (216, 330, 116, 5, 5. , 4.5, 3.744, 1, 0.93),\n",
              "       (217, 322, 112, 4, 4.5, 4.5, 3.704, 1, 0.91),\n",
              "       (218, 321, 109, 4, 4. , 4. , 3.652, 1, 0.85),\n",
              "       (219, 324, 110, 4, 3. , 3.5, 3.588, 1, 0.84),\n",
              "       (230, 324, 111, 4, 3. , 3. , 3.604, 1, 0.82),\n",
              "       (235, 330, 113, 5, 5. , 4. , 3.724, 1, 0.91),\n",
              "       (236, 326, 111, 5, 4.5, 4. , 3.692, 1, 0.88),\n",
              "       (237, 325, 112, 4, 4. , 4.5, 3.668, 1, 0.85),\n",
              "       (238, 329, 114, 5, 4.5, 5. , 3.676, 1, 0.86),\n",
              "       (246, 328, 110, 4, 4. , 2.5, 3.608, 1, 0.81),\n",
              "       (254, 335, 115, 4, 4.5, 4.5, 3.872, 1, 0.93),\n",
              "       (255, 321, 114, 4, 4. , 5. , 3.648, 0, 0.85),\n",
              "       (260, 331, 119, 4, 5. , 4.5, 3.736, 1, 0.9 ),\n",
              "       (261, 327, 108, 5, 5. , 3.5, 3.652, 1, 0.87),\n",
              "       (269, 327, 113, 4, 4.5, 5. , 3.656, 0, 0.83),\n",
              "       (277, 329, 113, 5, 5. , 4.5, 3.78 , 1, 0.89),\n",
              "       (283, 312, 106, 3, 4. , 3.5, 3.516, 1, 0.81),\n",
              "       (285, 340, 112, 4, 5. , 4.5, 3.864, 1, 0.94),\n",
              "       (286, 331, 116, 5, 4. , 4. , 3.704, 1, 0.93),\n",
              "       (287, 336, 118, 5, 4.5, 4. , 3.676, 1, 0.92),\n",
              "       (288, 324, 114, 5, 5. , 4.5, 3.632, 1, 0.89),\n",
              "       (289, 314, 104, 4, 5. , 5. , 3.608, 0, 0.82),\n",
              "       (298, 320, 120, 3, 4. , 4.5, 3.644, 0, 0.86),\n",
              "       (299, 330, 114, 3, 4.5, 4.5, 3.696, 1, 0.9 ),\n",
              "       (312, 328, 108, 4, 4.5, 4. , 3.672, 1, 0.84),\n",
              "       (326, 326, 116, 3, 3.5, 4. , 3.656, 1, 0.81),\n",
              "       (336, 325, 111, 4, 4. , 4.5, 3.644, 1, 0.83),\n",
              "       (338, 332, 118, 5, 5. , 5. , 3.788, 1, 0.94),\n",
              "       (339, 323, 108, 5, 4. , 4. , 3.496, 1, 0.81),\n",
              "       (340, 324, 107, 5, 3.5, 4. , 3.464, 1, 0.81),\n",
              "       (360, 321, 107, 2, 2. , 1.5, 3.376, 0, 0.81),\n",
              "       (361, 322, 110, 3, 4. , 5. , 3.456, 1, 0.85),\n",
              "       (362, 334, 116, 4, 4. , 3.5, 3.816, 1, 0.93),\n",
              "       (363, 338, 115, 5, 4.5, 5. , 3.692, 1, 0.91),\n",
              "       (366, 330, 114, 4, 4.5, 3. , 3.668, 1, 0.86),\n",
              "       (372, 324, 110, 3, 3.5, 3. , 3.688, 1, 0.89),\n",
              "       (373, 336, 119, 4, 4.5, 4. , 3.848, 1, 0.95),\n",
              "       (383, 324, 110, 4, 4.5, 4. , 3.66 , 1, 0.82),\n",
              "       (385, 340, 113, 4, 5. , 5. , 3.896, 1, 0.96),\n",
              "       (386, 335, 117, 5, 5. , 5. , 3.928, 1, 0.96),\n",
              "       (393, 326, 112, 4, 4. , 3.5, 3.648, 1, 0.84),\n",
              "       (395, 329, 111, 4, 4.5, 4. , 3.692, 1, 0.89),\n",
              "       (396, 324, 110, 3, 3.5, 3.5, 3.616, 1, 0.82),\n",
              "       (397, 325, 107, 3, 3. , 3.5, 3.644, 1, 0.84),\n",
              "       (398, 330, 116, 4, 5. , 4.5, 3.78 , 1, 0.91),\n",
              "       (400, 333, 117, 4, 5. , 4. , 3.864, 1, 0.95)],\n",
              "      dtype=[('Serial_No', '<i8'), ('GRE_Score', '<i8'), ('TOEFL_Score', '<i8'), ('University_Rating', '<i8'), ('SOP', '<f8'), ('LOR', '<f8'), ('CGPA', '<f8'), ('Research', '<i8'), ('Chance_of_Admit', '<f8')])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g4mib3PJTCv5",
        "outputId": "1e0a19fc-7eb2-42a1-b8d1-787a7e48a414"
      },
      "source": [
        "# Let's also do this with GPA\n",
        "print(graduate_admission[graduate_admission['Chance_of_Admit'] > 0.8]['CGPA'].mean())\n",
        "print(graduate_admission[graduate_admission['Chance_of_Admit'] < 0.4]['CGPA'].mean())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.7106666666666666\n",
            "3.0222857142857142\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rl7v0yYZTCv6"
      },
      "source": [
        "# Hrm, well, I guess one could have expected this. The GPA and GRE for students who have a higher chance of\n",
        "# being admitted, at least based on our cursory look here, seems to be higher."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cRv2uuJ3TCv6"
      },
      "source": [
        "So that's a bit of a whirlwing tour of numpy, the core scientific computing library in python. Now, you're\n",
        "going to see a lot more of this kind of discussion, as the library we'll be focusing on in this course is\n",
        "pandas, which is built on top of numpy. Don't worry if it didn't all sink in the first time, we're going to\n",
        "dig in to most of these topics again with pandas. However, it's useful to know that many of the functions\n",
        "and capabilities of numpy are available to you within pandas."
      ]
    }
  ]
}