Numpy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Numpy.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyM2MDJkW+G/KZOAJAFbaqIw",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/vvthakral/Python-for-AI-Data-Science/blob/master/Numpy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XCULoGp28OY7",
        "colab_type": "text"
      },
      "source": [
        "<center>Numpy Basics</center>\n",
        "\n",
        "It is the core library for scientific computing in python and provides a high-performance multidimensional array object, and tools for working with these arrays.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZuoE6LvP8oA4",
        "colab_type": "text"
      },
      "source": [
        "What we cover in this notebook?\n",
        "\n",
        "Introduction to numpy arrays: \n",
        "1.   Creation\n",
        "2.   Shape /Size\n",
        "3.   Access/Slice \n",
        "4.   Reverse\n",
        "5.   Masking\n",
        "\n",
        "Represent missing values and infinite.\n",
        "\n",
        "Compute mean, min, max on the ndarray?\n",
        "\n",
        "Reshaping and flattening Multidimensional arrays\n",
        "\n",
        "Creating sequences, repetitions, and random numbers\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1X47Zc8z8wUp",
        "colab_type": "code",
        "outputId": "a6cf97e5-604a-46bd-d0cc-5a6281220685",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 118
        }
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# Create a numpy array from list\n",
        "list_a = [1,2,3]\n",
        "a = np.array(list_a)   \n",
        "print(type(a))\n",
        "\n",
        "#Observe the class of the array printed            \n",
        "\n",
        "#Shape of the array\n",
        "print(a.shape)            \n",
        "\n",
        "#Accessing the array elements, very similar to lists\n",
        "print(a[0], a[1], a[2])\n",
        "\n",
        "#updating the array element\n",
        "a[0] = 0                \n",
        "print(a)          \n",
        "\n",
        "#np array has ranks, the one below is 2D array\n",
        "b = np.array([[1,2,3],[4,5,6]])    \n",
        "print(b.shape)                     \n",
        "print(b[0, 0], b[0, 1])"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'numpy.ndarray'>\n",
            "(3,)\n",
            "1 2 3\n",
            "[0 2 3]\n",
            "(2, 3)\n",
            "1 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BwRZsCroKgJl",
        "colab_type": "code",
        "outputId": "f78f0774-0118-4407-fa17-efb85492c330",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#Vector 1 dimensional\n",
        "list_a = [1,2,3]\n",
        "a = np.array(list_a)\n",
        "a.shape"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NAenEWBpM3Gu",
        "colab_type": "text"
      },
      "source": [
        "The key difference between an array and a list is, arrays are designed to handle vectorized operations while a python list is not.\n",
        "\n",
        "Numpy array behaves different to the python lists, any function performed on numpy array applies to every single item in the array, instead of the whole array object.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_FbYqz7YM5hg",
        "colab_type": "code",
        "outputId": "25d8d243-4241-4e0d-acb4-54a9f0969e3d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        }
      },
      "source": [
        "list_ = [1, 2]\n",
        "try:\n",
        "  print(list_ + 2)\n",
        "except:\n",
        "  print('We can\\'t do such things in python. Can we?')\n",
        "\n",
        "#We can do such updation in Numpy\n",
        "print('Numpy array a is: ',a)\n",
        "a += 2\n",
        "print('Updated value of a is: ',a)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "We can't do such things in python. Can we?\n",
            "Numpy array a is:  [1 2 3]\n",
            "Updated value of a is:  [3 4 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_wAks4wlOqKk",
        "colab_type": "code",
        "outputId": "ef7c7ae2-dfe0-49f6-833d-dd7893932339",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "f = 201\n",
        "print(f)\n",
        "def somefunc():\n",
        "  global f\n",
        "  f = 100\n",
        "print('Before',f)\n",
        "print('changing the value')\n",
        "somefunc()\n",
        "print('after',f)"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "201\n",
            "Before 201\n",
            "changing the value\n",
            "after 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e5PBPCDfOsvM",
        "colab_type": "text"
      },
      "source": [
        "We can't increase the size of numpy array like we do for python list. If we do need to add something we need to reassign the value(arary) to the variable."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8BXvcmGpOGlf",
        "colab_type": "text"
      },
      "source": [
        "We can specify the datatype of the elements in the numpy arrray by setting the dtype argument while initiating the array. \n",
        "\n",
        "We can use dtypes like: 'float', 'int', 'bool', 'str' and 'object'."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pbsev7ydOhYM",
        "colab_type": "code",
        "outputId": "13dd003d-639d-480b-a6fa-b7e6c2274efa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 118
        }
      },
      "source": [
        "list1 = [1, 2, 3, 4]\n",
        "custom_a = np.array(list1)\n",
        "print(custom_a)\n",
        "\n",
        "# Create a boolean array\n",
        "arr_b = np.array([1, 0, 10], dtype='bool')\n",
        "print('The boolean array is: ',arr_b)\n",
        "\n",
        "# Convert to 'int' datatype\n",
        "print('\\nThe integer dtype')\n",
        "print(custom_a.astype('int'))\n",
        "\n",
        "custom_a = custom_a.astype('int')\n",
        "# Convert to int then to str datatype\n",
        "custom_a.astype('int').astype('str')"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3 4]\n",
            "The boolean array is:  [ True False  True]\n",
            "\n",
            "The integer dtype\n",
            "[1 2 3 4]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['1', '2', '3', '4'], dtype='<U21')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i7XamWcgQD_P",
        "colab_type": "code",
        "outputId": "db37eab5-fbfe-4cc9-e112-84bdc222fb50",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Convert an array to a list\n",
        "a.tolist()"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3, 4, 5]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_HLE9f2LQdgJ",
        "colab_type": "text"
      },
      "source": [
        "Recap!\n",
        "\n",
        "1.Unlike the lists, numpy array can support vectorised operations.\n",
        "\n",
        "2.We can't update array size after creation.\n",
        "\n",
        "3.All items in an array are of the same dtype, this along with size condition are reason behind numpy array being faster than the python list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yp4fmrOGQukr",
        "colab_type": "code",
        "outputId": "dcacd585-3a1e-4a62-ffd5-97b178e73b44",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "list2 = [[1, 2, 3, 4],[3, 4, 5, 6], [5, 6, 7, 8]]\n",
        "arr2 = np.array(list2, dtype='float')\n",
        "arr2\n",
        "print('Shape: ', arr2.shape)\n",
        "\n",
        "# dtype\n",
        "print('Datatype: ', arr2.dtype)\n",
        "\n",
        "# size\n",
        "print('Size: ', arr2.size)\n",
        "\n",
        "# ndim\n",
        "print('Num Dimensions: ', arr2.ndim)\n"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Shape:  (3, 4)\n",
            "Datatype:  float64\n",
            "Size:  12\n",
            "Num Dimensions:  2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wYlZeAdNkih4",
        "colab_type": "code",
        "outputId": "fbdc5d98-121e-4235-bc7f-0dfd77c5ef02",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "arr2[:2, :2]\n",
        "list2[:2][:2]  # error"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1, 2, 3, 4], [3, 4, 5, 6]]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uFiwURhZkoMk",
        "colab_type": "code",
        "outputId": "24a6db27-3ebf-482e-97e5-1d32c94596b8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        }
      },
      "source": [
        "#Masking\n",
        "b = arr2 > 4\n",
        "b"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[False, False, False, False],\n",
              "       [False, False,  True,  True],\n",
              "       [ True,  True,  True,  True]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z-cq_dtxkrL8",
        "colab_type": "code",
        "outputId": "ed4b14c4-a45d-4bd7-a36c-7e45b36d8988",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "arr2[b]"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5., 6., 5., 6., 7., 8.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tNQNs-xTk1sK",
        "colab_type": "text"
      },
      "source": [
        "Missing Values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qjLsuI7fkxpW",
        "colab_type": "code",
        "outputId": "8009d140-3889-4d1b-eff7-cdb798548541",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        }
      },
      "source": [
        "arr2[1,1] = np.nan  # not a number\n",
        "arr2[1,2] = np.inf  # infinite\n",
        "arr2"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1.,  2.,  3.,  4.],\n",
              "       [ 3., nan, inf,  6.],\n",
              "       [ 5.,  6.,  7.,  8.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tHLXd3lfk0zn",
        "colab_type": "code",
        "outputId": "02890e3f-bbe1-4853-b1d0-8e292b9197ab",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        }
      },
      "source": [
        "missing_bool = np.isnan(arr2) | np.isinf(arr2)\n",
        "missing_bool"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[False, False, False, False],\n",
              "       [False,  True,  True, False],\n",
              "       [False, False, False, False]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aDQohi3sVsFM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "474d597e-0bc3-4da8-cc6e-051b1a294884"
      },
      "source": [
        "arr2[missing_bool] = -1  \n",
        "arr2"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1.,  2.,  3.,  4.],\n",
              "       [ 3., -1., -1.,  6.],\n",
              "       [ 5.,  6.,  7.,  8.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SJ3INrqLk7fE",
        "colab_type": "text"
      },
      "source": [
        "How to compute mean, min, max on the ndarray?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "udcrLvtHk_gc",
        "colab_type": "code",
        "outputId": "5d6177a3-b0f9-4d31-e69f-cf78d717dacb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        }
      },
      "source": [
        "print(\"Mean value is: \", arr2.mean())\n",
        "print(\"Max value is: \", arr2.max())\n",
        "print(\"Min value is: \", arr2.min())"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mean value is:  3.5833333333333335\n",
            "Max value is:  8.0\n",
            "Min value is:  -1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ojtDuXnDlEfd",
        "colab_type": "code",
        "outputId": "3e1a8294-2fa6-42df-9a7e-26b0fde32244",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "#Row wise \n",
        "print(\"Column wise minimum: \", np.amin(arr2))\n",
        "print(\"Row wise minimum: \", np.amin(arr2, axis=1))"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Column wise minimum:  -1.0\n",
            "Row wise minimum:  [ 1. -1.  5.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4bgCppLKlPxI",
        "colab_type": "text"
      },
      "source": [
        "Copying array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0KYdo_-UlTUd",
        "colab_type": "code",
        "outputId": "71407414-70ce-492f-da7b-5ca5849c79f9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        }
      },
      "source": [
        "# Assign portion of arr2 to arr2a. Doesn't really create a new array.\n",
        "arr2a = arr2[:2,:2]  \n",
        "arr2a[:1, :1] = 100  # 100 will reflect in arr2\n",
        "print(arr2a)\n",
        "print('\\n',arr2[:2,:2])"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[100.   2.]\n",
            " [  3.  -1.]]\n",
            "\n",
            " [[100.   2.]\n",
            " [  3.  -1.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "apyX1iYDlWSD",
        "colab_type": "text"
      },
      "source": [
        "Strange right?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O8z3qImSlXFM",
        "colab_type": "code",
        "outputId": "a6027291-0c88-4e14-e410-a915dd249e50",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        }
      },
      "source": [
        "#The right method!\n",
        "arr2b = arr2[:2, :2].copy()\n",
        "arr2b[:1, :1] = 101  # 101 will not reflect in arr2\n",
        "print(arr2b)\n",
        "arr2"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[101.   2.]\n",
            " [  3.  -1.]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[100.,   2.,   3.,   4.],\n",
              "       [  3.,  -1.,  -1.,   6.],\n",
              "       [  5.,   6.,   7.,   8.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x3F4qgMblegZ",
        "colab_type": "text"
      },
      "source": [
        "Reshaping "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DA9PYZ8FmPBo",
        "colab_type": "code",
        "outputId": "2f3fe0c0-3c34-4109-f03e-10aec1f9a51e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 168
        }
      },
      "source": [
        "print(arr2)\n",
        "print('\\n')\n",
        "arr2.reshape(4, 3)"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[100.   2.   3.   4.]\n",
            " [  3.  -1.  -1.   6.]\n",
            " [  5.   6.   7.   8.]]\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[100.,   2.,   3.],\n",
              "       [  4.,   3.,  -1.],\n",
              "       [ -1.,   6.,   5.],\n",
              "       [  6.,   7.,   8.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-JlWcG9imGWl",
        "colab_type": "text"
      },
      "source": [
        "How to create sequences, repetitions and random numbers using numpy?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JbQgqLv5mDHj",
        "colab_type": "code",
        "outputId": "af003ce1-72fe-48df-ffcf-a7f1af415c73",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "# Lower limit is 0 be default\n",
        "print(np.arange(5))  \n",
        "\n",
        "# 0 to 9\n",
        "print(np.arange(0, 10))  \n",
        "\n",
        "# 0 to 9 with step of 2\n",
        "print(np.arange(0, 10, 2))  \n",
        "\n",
        "# 10 to 1, decreasing order\n",
        "print(np.arange(10, 0, -1))"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4]\n",
            "[0 1 2 3 4 5 6 7 8 9]\n",
            "[0 2 4 6 8]\n",
            "[10  9  8  7  6  5  4  3  2  1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N5tI8EufmAiH",
        "colab_type": "code",
        "outputId": "f93ae17e-59f0-4502-c655-1ff95a60b802",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "np.linspace(start=1, stop=50, num=10, dtype=int)"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1,  6, 11, 17, 22, 28, 33, 39, 44, 50])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pgk0tbkxmwSx",
        "colab_type": "code",
        "outputId": "77781abe-7af5-40b3-d311-45f48dcc3f35",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        }
      },
      "source": [
        "print(np.zeros([2,3]))\n",
        "print(' ')\n",
        "print(np.ones([2,2]))"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0. 0. 0.]\n",
            " [0. 0. 0.]]\n",
            " \n",
            "[[1. 1.]\n",
            " [1. 1.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sfsT5jFSm2NM",
        "colab_type": "code",
        "outputId": "a3fb87a0-107b-4217-9696-2bd65c4a7f00",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        }
      },
      "source": [
        "# Random numbers between [0,1) of shape 2,2\n",
        "print(np.random.rand(2,2))\n",
        "print('\\n')\n",
        "# Normal distribution with mean=0 and variance=1 of shape 2,2\n",
        "print(np.random.randn(2,2))\n",
        "\n",
        "# Random integers between [0, 10) of shape 2,2\n",
        "print(np.random.randint(0, 10, size=[2,2]))\n",
        "\n",
        "# One random number between [0,1)\n",
        "print(np.random.random())\n",
        "\n",
        "# Random numbers between [0,1) of shape 2,2\n",
        "print(np.random.random(size=[2,2]))\n",
        "\n",
        "# Pick 10 items from a given list, with equal probability\n",
        "print(np.random.choice(['a', 'e', 'i', 'o', 'u'], size=10))  \n",
        "\n",
        "# Pick 10 items from a given list with a predefined probability 'p'\n",
        "print(np.random.choice(['a', 'e', 'i', 'o', 'u'], size=10, p=[0.3, .1, 0.1, 0.4, 0.1]))  # picks more o's"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0.51485894 0.79186099]\n",
            " [0.53738844 0.62897699]]\n",
            "\n",
            "\n",
            "[[-0.38192398 -0.54315642]\n",
            " [ 0.0672156  -0.80718178]]\n",
            "[[9 7]\n",
            " [7 8]]\n",
            "0.02715317239891557\n",
            "[[0.33554238 0.08674587]\n",
            " [0.84617247 0.9503866 ]]\n",
            "['e' 'i' 'e' 'o' 'u' 'u' 'o' 'u' 'i' 'e']\n",
            "['a' 'a' 'o' 'a' 'o' 'o' 'e' 'u' 'o' 'i']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6hu8EyjBbiO4",
        "colab_type": "code",
        "outputId": "602694a8-eed1-4ec7-aa67-abbb4edee692",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "a = (np.random.choice(['a','b','c','i'], size=10000))\n",
        "a[a=='i']"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['i', 'i', 'i', ..., 'i', 'i', 'i'], dtype='<U1')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KEIAiCQDeD7J",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e79e111a-c233-420f-b8df-ca6287a08855"
      },
      "source": [
        "import numpy as np\n",
        "options  = ['i', 'o', 'u']\n",
        "option_prob = [0.5, 0.1, 0.4]\n",
        "selected = (np.random.choice(options, size=1000, p=option_prob))  # picks more o's\n",
        "total_size = selected.size\n",
        "total_size"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1000"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b2KZXhim243w",
        "colab_type": "code",
        "outputId": "080c45e3-0779-4826-8349-917835f444d0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        }
      },
      "source": [
        "for i in options:\n",
        "  count_i = selected[selected==i].size\n",
        "  print('{} occurs {} times in the custom made array and the ratio of occurence is {}'.format(i,count_i,count_i/total_size))"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "i occurs 505 times in the custom made array and the ratio of occurence is 0.505\n",
            "o occurs 113 times in the custom made array and the ratio of occurence is 0.113\n",
            "u occurs 382 times in the custom made array and the ratio of occurence is 0.382\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wXqorFca2cMU",
        "colab_type": "code",
        "outputId": "82212c6b-7298-489f-e5aa-13361a356d21",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 118
        }
      },
      "source": [
        "\n",
        "#Python way of counting \n",
        "print('\\nPython way of counting\\n')\n",
        "for i in options:\n",
        "  count = 0\n",
        "  for j in selected:\n",
        "    if j==i:\n",
        "      count+=1\n",
        "  print('count of {} is {}'.format(i,count))  "
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Python way of counting\n",
            "\n",
            "count of i is 505\n",
            "count of o is 113\n",
            "count of u is 382\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rrqv8Tb6h-Sp",
        "colab_type": "code",
        "outputId": "1f010f6d-e4f2-418b-ae18-35b123603546",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "# Create an array\n",
        "\n",
        "arr_rand = np.array([8, 8, 3, 7, 7, 0, 4, 2, 5, 2])\n",
        "print(\"Array: \", arr_rand)\n",
        "\n",
        "# Positions where value > 5\n",
        "index_gt5 = np.where(arr_rand >5)\n",
        "print(\"Positions where value > 5: \", index_gt5)"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Array:  [8 8 3 7 7 0 4 2 5 2]\n",
            "Positions where value > 5:  (array([0, 1, 3, 4]),)\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}