Tutorial_Python_Data_Manipulation_tools.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Tutorial-Python-Data-Manipulation-tools.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tolotrasamuel/Tutorial-Python-Data-Manipulation-tools/blob/master/Tutorial_Python_Data_Manipulation_tools.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "metadata": {
        "id": "7UV8v2kdVscb",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Intro to NumPy\n",
        "\n",
        "NumPy is the fundamental package for scientific computing in Python. NumPy is used in many other packages in python even though you may not see it explicitly running in your code.\n",
        "\n",
        "It is a python library that provides a multidimensional array object, various derived objects (such as masked arrays and matrices), and an assortment of routines for fast operations on arrays, including mathematical, logical, shape manipulation, sorting, selecting, I/O, discrete Fourier transforms, basic linear algebra, basic statistical operations, random simulation and much more.\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "fkjpKVmZVscc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Import the numpy package"
      ]
    },
    {
      "metadata": {
        "id": "oFl5JU9fVscd",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import numpy as np "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Wi_iVJZcVsch",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Make an array from a list. \n",
        "\n",
        "This will create a numpy array with 3 elements. \n",
        "\n",
        "Each numpy array contains an attribute called `shape`. Shape is a tuple which tells you how many elements you have per axis. For example (5, 6, 8) means 5 elements per axis 0, 6 elements per axis 1 and 8 elements per axis 2. Usually you will have only one or two axes.\n",
        "\n",
        "The shape for the array in this section is `(3, )`. The reason for this funny notation is python's type system where shape must be a tuple and this is a tuple with 1 element. Writing just 3 would mean a number, not a tuple.\n",
        "\n",
        "To verify that try `np.array([1, 2, 3]).shape` "
      ]
    },
    {
      "metadata": {
        "id": "hiCYmtPGVsch",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "np.array([1, 2, 3])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "stlK-cUIVscm",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Make an array from a list of lists\n",
        "\n",
        "The shape of this array is (2, 2) so this is a matrix."
      ]
    },
    {
      "metadata": {
        "id": "0R0OYUEgVscn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "872fe8b7-15e6-4fe2-b71a-017a769bbdc7"
      },
      "cell_type": "code",
      "source": [
        "np.array([[1, 2], [3, 4]])"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [3, 4]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "metadata": {
        "id": "XlI6D-_IVscq",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Make an array using a function\n",
        "\n",
        "The arrays made in previous sections were based on us supplying each value.\n",
        "\n",
        "Very often we need large arrays and it is not possible to use our current approach and thus we need to use array creating functions. The most important functions are `zeros` and `ones`. They both take a parameter called shape which determines the shape of the output array.\n",
        "* `zeros` makes an array which is all 0 [docs](https://docs.scipy.org/doc/numpy/reference/generated/numpy.zeros.html)\n",
        "* `ones`  makes an array which is all 1 [docs](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ones.html#numpy.ones)"
      ]
    },
    {
      "metadata": {
        "id": "VbIimhBLVscr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "5896cccd-c98b-4fc6-fdb8-3a754edcccfc"
      },
      "cell_type": "code",
      "source": [
        "np.zeros((2, 3))"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "metadata": {
        "id": "2ehKzKEsVsct",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "87d30ab1-d980-4e54-8434-93f8bfc58331"
      },
      "cell_type": "code",
      "source": [
        "np.ones((3, 2))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1.],\n",
              "       [1., 1.],\n",
              "       [1., 1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "metadata": {
        "id": "SYWOfj3GVscx",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Make an array by starting at 0, incrementing by 2 and ending before 10\n",
        "\n",
        "`arange` is the exact same thing as regular python `range` except giving back a numpy array.\n",
        "\n",
        "This functions requires only a single argument which is the end point. The start point is assumed to be 0 and step is assumed to be 1.\n",
        "\n",
        "In this variety when in takes three parameters, the first one is the start, second one is the end and the third one is the step.\n",
        "\n",
        "\n",
        "[docs](https://docs.scipy.org/doc/numpy/reference/generated/numpy.arange.html)\n",
        "##start from (exactly) 1 , end at 10 (inclusive), step 2"
      ]
    },
    {
      "metadata": {
        "id": "YmUE2XZIVscx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7f72d7bc-1e47-4965-e94c-f9960a1c428a"
      },
      "cell_type": "code",
      "source": [
        "np.arange(1, 10, 2) "
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 3, 5, 7, 9])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "metadata": {
        "id": "D2di29HcgA-p",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The same as  np.arange(0, 10, 1) "
      ]
    },
    {
      "metadata": {
        "id": "7SKmPZkif_p0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b2032d88-1b5d-4aae-a343-fdc8363a2cc2"
      },
      "cell_type": "code",
      "source": [
        "x = np.arange(10) \n",
        "print(x)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "ptTTTAE9fQ3s",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Try here"
      ]
    },
    {
      "metadata": {
        "id": "EOUAnSaXfNxg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "498e2ce4-94f6-4263-c2f6-be7d87f4f584"
      },
      "cell_type": "code",
      "source": [
        "x = np.arange(0, 10, 1) \n",
        "print(x)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "WgfvR8_eVsc0",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Make an array of four evenly spaced numbers including both endpoints"
      ]
    },
    {
      "metadata": {
        "id": "CmQ2LtbjVsc2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "64f1d9f9-1419-43c7-d8e0-5872e4f06409"
      },
      "cell_type": "code",
      "source": [
        "np.linspace(0, 1, 4)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.        , 0.33333333, 0.66666667, 1.        ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "metadata": {
        "id": "pSwe4s-6Vsc6",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Make an array of random numbers (using a normal distribution)\n",
        "\n",
        "The random submodule of numpy contains a variety of functions for generating random numbers following a specified probability distributions or sampling from a finite set of choices. To learn more about it visit the [documentation](https://docs.scipy.org/doc/numpy/reference/routines.random.html). "
      ]
    },
    {
      "metadata": {
        "id": "rIVnHqRNVsc6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "mean = 10\n",
        "stdev = 3\n",
        "number_values = 20\n",
        "np.random.normal(mean, stdev, number_values)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "gPZuEtnjVsc9",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Indexing Arrays\n",
        "#### Access elements of a 1-dimensional array.  Get the first and last element.\n",
        "\n",
        "In python as is in many other programming languages all arrays start from 0 so the first element is at position 0.\n",
        "\n",
        "To access the last element we can use -1 as the index. `x[-1]` is identical to `x[x.shape[0] - 1]` where `shape[0]` is the length of the array."
      ]
    },
    {
      "metadata": {
        "id": "TTfE_CDUVsc-",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "x = np.arange(4)\n",
        "\n",
        "print(x[0])\n",
        "print(x[-1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "TzlouFp2VsdD",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Reshape an array\n",
        "\n",
        "Remember that shape is the fundamenal property of each array and we can modify it as we desire and we often do so. To change the shape of an array we use the `reshape` method.\n",
        "\n",
        "The code in this example creates an 1D-array of 6 elements using the `arange` functon.\n",
        "\n",
        "We convert it to a 2D-array using the `reshape` method.\n",
        "\n",
        "You see that the total amount of numbers did not change, only our view of them. 6 elements in a vector or 3 x 2 elements in a matrix.\n",
        "\n",
        "It is very important that when using `reshape` to ensure that dimensions match or you will get an error. 6 = 3 x 2 is a match so this works but trying np.arange(6).reshape(4, 2) will give you an error. \n",
        "\n",
        "[docs](https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html)"
      ]
    },
    {
      "metadata": {
        "id": "L-99GhjBVsdE",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "x = np.arange(6).reshape(2, 3)\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "PJwakKH2VsdG",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Get the last row\n",
        "\n",
        "When dealing with arrays which are of more than a single dimension we can use partial indexing specifications go slice the array the way we want. \n",
        "\n",
        "For example `print(x[-1])` will print the last **row**.\n",
        "\n",
        "To get the last column take the transpose of the 2d-array and then use [-1]. \n",
        "\n",
        "For exampe `print(x.T[-1])` will give you the last columns. `x.T` is the transpose of `x`"
      ]
    },
    {
      "metadata": {
        "id": "eRzSoVEBVsdH",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(x[-1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "lLqO8U4ZVsdL",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Get the last element of the last row\n",
        "\n",
        "Here we are using full indexing to get a single **element**."
      ]
    },
    {
      "metadata": {
        "id": "ktEhAKY0VsdL",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(x[-1, -1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "S_vuadjsVsdO",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Get elements like a list\n",
        "\n",
        "Using the notation `a:b` we can slice arrays as precisely as we want.\n",
        "\n",
        "`a:b` means give me back all elements whose positions is in that set.\n",
        "\n",
        "For example `y = [1, 3, 5, 7, 9]` and `y[0:2]` would give us the first two elements `[1, 3]`.\n",
        "\n",
        "Negative indices mean from back so -3 means 3 positions starting from the last position.\n",
        "\n",
        "Experiment with the values until you get the feel for it."
      ]
    },
    {
      "metadata": {
        "id": "Q6coPcKdVsdO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ec546514-1517-4587-daea-c24b377d4911"
      },
      "cell_type": "code",
      "source": [
        "x = np.arange(10) \n",
        "print(x)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "mz4G7OHsgcYu",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# #from index 0 to 4 (returns np array of length 5)"
      ]
    },
    {
      "metadata": {
        "id": "mLuj8IktgTjG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4ceb458e-0109-4391-f665-dba8e9a2ea65"
      },
      "cell_type": "code",
      "source": [
        "x[:5]\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "metadata": {
        "id": "AcOt_6Nxg7Ci",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#returns last 3 elements"
      ]
    },
    {
      "metadata": {
        "id": "_2mIXT4kgwqZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "30216b6b-00c5-4447-e1c8-83afd6be4561"
      },
      "cell_type": "code",
      "source": [
        "print(x[-3:])"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[7 8 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "TWdaBHCzhEc1",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## First 3 elements"
      ]
    },
    {
      "metadata": {
        "id": "SYmJoedRfytX",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(x[:3])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "357FsjMthJex",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "##from index 1 to 3 (returns np array of length 3) (1 inclusive, 4 exclusive)"
      ]
    },
    {
      "metadata": {
        "id": "CpDzxiJNhLfn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "cee94e34-23c7-45e3-c6fb-1dcee41bebb9"
      },
      "cell_type": "code",
      "source": [
        "print(x[1:4])"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "u0LUGU7QVsdR",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Get all elements in reverse order\n",
        "\n",
        "The enhanced slicing syntax is `a:b:c` were `c` is the step. For example `0:10:2`.\n",
        "\n",
        "If we omit `a` and `b` we always asume they are `a` = 0 and `b` = length of the list so we are only left with a step.\n",
        "\n",
        "Thus `::2` means slicing from 0 to end with a step 2. `::3` mean slicing with a step 3.\n",
        "\n",
        "Now what if we used negative steps. Using -1 as the step would reverse the logic and `a` becomes the end of the list and `b` becomes zero. So `::-1` will slice in reverse direction.\n",
        "\n",
        "Finally there is also the slice form `::1` or written short `:` which means give me back all elements in order as they are present."
      ]
    },
    {
      "metadata": {
        "id": "4UzObVzGVsdS",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(x[::-1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "RYDI0tKZVsdV",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Get every second element or third element"
      ]
    },
    {
      "metadata": {
        "id": "Qt1WeSeUVsdW",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(x[::2])\n",
        "print(x[::3])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "gTtzstSeVsdZ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Create a 5x5 matrix"
      ]
    },
    {
      "metadata": {
        "id": "QGlTQXhwVsda",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "x = np.arange(25).reshape(5, 5)\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "13f9XrWfVsdc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Get the first two columns and the first two rows\n",
        "\n",
        "Until now you have learned how to slice on a 1D array but slices can be generalized to any dimensional arrays.\n",
        "\n",
        "The trick is to create a slice for every dimensions. \n",
        "\n",
        "In this example we have a 2d-array so we create two slices, one for dimension 0 (rows) and one for dimension 1 (columns)\n"
      ]
    },
    {
      "metadata": {
        "id": "sU273gC3Vsdd",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(x[:2, :2])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "k4o5CSY-Vsdg",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Get every second column of every second row"
      ]
    },
    {
      "metadata": {
        "id": "v1RkC6_XVsdg",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(x[::2, ::2])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "VUN97--UVsdj",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Access parts of an array with index arrays"
      ]
    },
    {
      "metadata": {
        "id": "LpR2l52dVsdj",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Generate six random integers between 0 and 9 inclusive\n",
        "\n",
        "`randint` in `np.random` is a very useful function which generates uniformly distributed random integers from the range provided as its first two parameters (start and end of range respectively). It's third parameter tells the method how many numbers we need."
      ]
    },
    {
      "metadata": {
        "id": "1nY57f_oVsdk",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "x = np.random.randint(0, 10, 6) \n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "bkjGnJKEVsdo",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Get the first number and the last two numbers\n",
        "\n",
        "Slices are inhetently linear and give us access to arrays in a linear fashion.\n",
        "\n",
        "To access elements in any order we must use index arrays which are numpy arrays holding integer numbers which tell what elements to chose from the indexed array."
      ]
    },
    {
      "metadata": {
        "id": "GWxn2lx2Vsdp",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "indices = [0, -2, -1]\n",
        "print(x[indices])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "5RfG_quvVsdr",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Create two arrays\n",
        "\n",
        "The array `x2` is created as `x1 * -1`. The multiplication operator here means multiply all elements of `x1` with -1 and give back that as result."
      ]
    },
    {
      "metadata": {
        "id": "V46GuSJOVsdr",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "arrayLength = 5\n",
        "x1 = np.arange(arrayLength)\n",
        "x2 = np.arange(arrayLength) * -1\n",
        "\n",
        "print(x1)\n",
        "print(x2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Qm54IQiiVsdu",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Create a random shuffled range of numbers\n",
        "\n",
        "This and the following example shows how to shuffle an array in numpy.\n",
        "\n",
        "Shuffling means reoreding the items in an array and we can do that using random permutations of the array positions."
      ]
    },
    {
      "metadata": {
        "id": "-XfqUqd8Vsdv",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "indices = np.random.permutation(arrayLength)\n",
        "print(indices)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "At69gWFaVsdz",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Use indices to re-order arrays"
      ]
    },
    {
      "metadata": {
        "id": "bqfTE7IEVsd0",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(x1[indices])\n",
        "print(x2[indices])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JhA7z7NiVsd5",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Create array of boolean values\n",
        "\n",
        "The main novelty of this example is `print(x > 2)`.\n",
        "\n",
        "`x > 2` generates an array of boolean values where each element is True or False.\n",
        "Having True at position i of the output means that the conditions is satisfied for the element of `x` at position i.\n",
        "\n",
        "For exampe if `x=[0,1,2,3,4]` then `x > 2` would be `[False, False, False, True, True]`.\n",
        "\n",
        "As you see 0 > 2 = False, 1 > 2 = False, 2 > 2 = False, 3 > 2 = True and 4 > 2 = True and that is shown in the output array."
      ]
    },
    {
      "metadata": {
        "id": "Wq39t_tDVsd6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "x = np.arange(5)\n",
        "print(x)\n",
        "print(x > 2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "k5Zv-VArVsd8",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Use boolean values to index arrays\n",
        "\n",
        "Once we have created our boolean array we can use it to index other arrays.\n",
        "\n",
        "The rule is very simple. If at position i of index we have True include `x[i]` in the output."
      ]
    },
    {
      "metadata": {
        "id": "E4ea2NQwVsd9",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "print(x[x > 2])\n",
        "print(x[np.array([False,False,False,True,True])])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "CPA6fxsgVseB",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Array Math"
      ]
    },
    {
      "metadata": {
        "id": "BXU-_j3XYjIx",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Try adding to a list"
      ]
    },
    {
      "metadata": {
        "id": "77uE0DtkVseC",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "x = [1, 2, 3, 4]\n",
        "\n",
        "print(x + 10)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "TmH2s9-aVseE",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Try again with an array\n",
        "\n",
        "When trying with a list you got an error because simple python lists do not support addition with scalars.\n",
        "\n",
        "But numpy arrays do allow that."
      ]
    },
    {
      "metadata": {
        "id": "oOmv1DBxVseE",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "x = np.array(x)\n",
        "\n",
        "print(x)\n",
        "print(x + 10)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "XvwnrdEsVseH",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Exercises"
      ]
    },
    {
      "metadata": {
        "id": "Xf0nHJl3VseH",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Create an array from 0 to 26 assign it to a variable x"
      ]
    },
    {
      "metadata": {
        "id": "CFzHAXotVseI",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "gSpgRMsjVseK",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Reverse the order of the array and print it out"
      ]
    },
    {
      "metadata": {
        "id": "Xg3yZ1yYVseL",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "9C0WP05VVseR",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Convert the 1-dimensional array you created into a 3 dimensional array"
      ]
    },
    {
      "metadata": {
        "id": "S1EwyyqfVseS",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "30CSoki5VseU",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Find the index (location) for value 12"
      ]
    },
    {
      "metadata": {
        "id": "3en3QEIXVseV",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "aIawXcgSVseb",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Create a random shuffled list of values from 0-19 and assign it to variable y"
      ]
    },
    {
      "metadata": {
        "id": "G9hLCgCeVseb",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "aRe_-tIOVsee",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Create an array of boolean values for values in y that are greater than 10"
      ]
    },
    {
      "metadata": {
        "id": "wZ3zDBh-Vsee",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "r8XL5KlKVseg",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Create a random sample of 20 data points from a normal distribution with mean of 10 and standard deviation 5"
      ]
    },
    {
      "metadata": {
        "id": "zwFXB9qbVseh",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}