TRC_Numpy_day_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyP0wtylhfYa5CPSBBLcflQ2"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "# **Learning Numpy**\n",
        "\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "5x9V9U9ZDJqM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "### Introduction\n",
        "\n",
        "*   Before using numpy in our programs we have to import it.\n",
        "\n",
        "\n",
        "```\n",
        "import numpy\n",
        "numpy.__version__\n",
        "```\n",
        "\n",
        "or\n",
        "\n"
      ],
      "metadata": {
        "id": "ukq19d98Lsfu"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "n2spX5anR5UU",
        "outputId": "b30e2561-ad61-4b70-ffe7-1a5b15a84b83"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1.23.5'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "import numpy as np\n",
        "np.__version__"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note:\n",
        "\n",
        "\n",
        "*   Numpy array is just like normal arrays in C++ or Java\n",
        "*   Numpy array is faster than python list as it doesn't have to figure out what is the data type the element is!\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "B5FxC-ueFuxM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Converting array into a list\n",
        "l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "arr_l = np.array(l)\n",
        "print(\"Data type of l:\",type(l))\n",
        "print(\"Data type of arr_l:\",type(arr_l)) # ndarray objects"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tRECNb6YT_34",
        "outputId": "23d38b44-be2b-4d1c-cb71-f1a26891f1a3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data type of l: <class 'list'>\n",
            "Data type of arr_l: <class 'numpy.ndarray'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Data Sets\n",
        "This is the data sets we'll be working with! :)"
      ],
      "metadata": {
        "id": "5fa-SEbzGcVU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# List of cloud technologies in 2023\n",
        "cloud_2023 = ['Amazon Web Services (AWS)', 'Firebase', 'Cloudflare', 'Google Cloud',\n",
        "              'Digital Ocean','Heroku', 'Vercel', 'Netlify', 'VMware', 'Hetzner',\n",
        "              'Linode, now Akamai', 'Managed Hosting', 'OVH','Oracle Cloud Infrastructure (OCI)',\n",
        "              'OpenShift', 'Fly.io', 'Vultr', 'Render', 'OpenStack','IBM Cloud Or Watson', 'Scaleway', 'Colocation', 'Microsoft Azure']\n",
        "\n",
        "# List of all votes for each cloud platform (Four values corresponds to one value in cloud_2023)\n",
        "votes_raw=[33818, 29479, 654, 1185,10761, 8550, 628, 486,10599, 8326, 420, 621,16592,\n",
        "           13304, 652, 866, 9299, 7838, 247, 393,8358, 6535, 492, 418,7431, 5727, 487,\n",
        "           392,6228, 4708, 498, 330,4964, 3584, 262, 396,3069, 2465, 67, 184, 2755, 2104,\n",
        "           125, 167,2379, 1889, 63, 137,2378, 1912, 76, 126,1810, 1146, 123, 190,1671, 1432, 22,\n",
        "           66, 1649, 1342, 72, 79,1357, 1021, 55, 94, 1287, 920, 132, 69,1076, 802, 53, 78,801,\n",
        "           571, 53, 70,628, 520, 0, 31,7, 385, 20, 30,18105, 15441, 370, 714]\n",
        "\n",
        "print(\"Data type of cloud_2023 :\",type(cloud_2023))\n",
        "print(\"Data type of votes_raw :\",type(votes_raw))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0rLX-tuNWF68",
        "outputId": "6801a2d2-adf0-4a83-dcbc-dd52269304ec"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data type of cloud_2023 : <class 'list'>\n",
            "Data type of votes_raw : <class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Converting list to numpy array\n",
        "\n",
        "\n",
        "*   cloud_2023 - > cloud_2023_array\n",
        "*   votes_raw - > votes_raw_array\n",
        "\n"
      ],
      "metadata": {
        "id": "dfa7pujKK7up"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "cloud_2023_array = np.array(cloud_2023)\n",
        "votes_raw_array = np.array(votes_raw)\n",
        "print(\"Data type of cloud_2023_array is \",type(cloud_2023_array))\n",
        "print(\"Data type of votes_raw_array is \",type(votes_raw_array))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XbJWqGsEI5Y9",
        "outputId": "d33b1ac6-8beb-424f-d4a8-229a00cd3863"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data type of cloud_2023_array is  <class 'numpy.ndarray'>\n",
            "Data type of votes_raw_array is  <class 'numpy.ndarray'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Properties:"
      ],
      "metadata": {
        "id": "ZWvQhGtmGoIB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Number of cloud services in the array\",cloud_2023_array.size) # Size property\n",
        "print(\"Shape of the array\",cloud_2023_array.shape) # Shape property | (23,) -> (23,1) | (m x n)\n",
        "print(\"Data type of each element in cloud_2023_array\",cloud_2023_array.dtype) # Data type property | U33 {U means Unicode and 33 means 33 bytes}\n",
        "print(\"Data type of each element in votes_raw_array\",votes_raw_array.dtype) #  Data type property | int64\n",
        "print(\"Number of dimensions of cloud_2023_array\",cloud_2023_array.ndim) # Dimension property | Number of square brackets"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mXD5NLUqWQID",
        "outputId": "e7ff9cdd-8d9b-4ac4-c8dd-e3c281753f55"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of cloud services in the array 23\n",
            "Shape of the array (23,)\n",
            "Data type of each element in cloud_2023_array <U33\n",
            "Data type of each element in votes_raw_array int64\n",
            "Number of dimensions of cloud_2023_array 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Type Casting\n",
        "\n",
        "\n",
        "*   We do this for better speed\n",
        "*   We shouldn't overdo it otherwise we'll run into space issues\n",
        "\n"
      ],
      "metadata": {
        "id": "mPQhiHHOHcKF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "votes_raw_array_32_bit = np.array(votes_raw,dtype=np.int32)\n",
        "print(votes_raw_array_32_bit)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q2Oh8xpDbUcS",
        "outputId": "ca1ff6af-916b-41e4-da45-8ed354b38e9c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[33818 29479   654  1185 10761  8550   628   486 10599  8326   420   621\n",
            " 16592 13304   652   866  9299  7838   247   393  8358  6535   492   418\n",
            "  7431  5727   487   392  6228  4708   498   330  4964  3584   262   396\n",
            "  3069  2465    67   184  2755  2104   125   167  2379  1889    63   137\n",
            "  2378  1912    76   126  1810  1146   123   190  1671  1432    22    66\n",
            "  1649  1342    72    79  1357  1021    55    94  1287   920   132    69\n",
            "  1076   802    53    78   801   571    53    70   628   520     0    31\n",
            "     7   385    20    30 18105 15441   370   714]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we use 16-bit instead of 32-bit we'll run into errors for large numbers\n",
        "\n",
        "\n",
        "```\n",
        "votes_raw_array_16_bit = np.array(votes_raw,dtype=np.int16)\n",
        "votes_raw_array_16_bit # The first number got screwed as it was too long\n",
        "```\n",
        "\n",
        "\n",
        "Feature:\n",
        "\n",
        "If it's the last line and we only write simply the name then we can print it (Google Collab feature)"
      ],
      "metadata": {
        "id": "8IVfoQzYHtmk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Upcasting\n",
        "\n",
        "\n",
        "*   Basically converting an hetrogenous list into a homogenous array\n"
      ],
      "metadata": {
        "id": "ALRDGAn0IQNs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "test = [1, 2.6, True]\n",
        "test_upcasted = np.array(test,dtype = \"int\")\n",
        "print(\"The follow array is the upcasted array:\")\n",
        "test_upcasted"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fcpVkNwXcy4u",
        "outputId": "9b70efa5-723e-4c7d-8700-3e8056ca3301"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The follow array is the upcasted array:\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 1])"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Reshaping\n",
        "\n",
        "\n",
        "*   Basically reshaping the data set according to our needs\n",
        "\n"
      ],
      "metadata": {
        "id": "ZMzkAUm2LF-c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"The shape of the votes_2023_array\",votes_raw_array.shape) # current shape"
      ],
      "metadata": {
        "id": "L6hSs0eNeFD_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d78c4c8d-d71c-4583-8c63-012a3dc772f0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The shape of the votes_2023_array (92,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's start off by experimenting with only 8 value and then we'll perform the similar action in the main data set"
      ],
      "metadata": {
        "id": "cN_pSFcolfFb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "test_arr = np.array([1,2,3,4,5,6,7,8])\n",
        "print(type(test_arr))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mCidd8uslebL",
        "outputId": "ec67c1a8-0e95-44d2-8748-b64b9c4fe444"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'numpy.ndarray'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We have to convert\n",
        "\n",
        "[1,2,3,4,5,6,7,8] ->[[1,2,3,4],[5,6,7,8]]\n",
        "\n",
        "1x8 -> 2x4"
      ],
      "metadata": {
        "id": "Z9MuQSzMmsSL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "reshape_test_arr = np.reshape(test_arr,(len(test_arr)//4,4))\n",
        "reshape_test_arr"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RFeCImsAnBij",
        "outputId": "76275dd7-ebeb-4909-aba7-cc91394e94d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3, 4],\n",
              "       [5, 6, 7, 8]])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We have used the floor division as the place where we have to use it expects a int not a float\n",
        "\n",
        "Now, let's do it with the main data set."
      ],
      "metadata": {
        "id": "-lUlqrTRnyZD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "merged_votes_array = np.reshape(votes_raw_array,(len(votes_raw_array)//4,4))\n",
        "print(\"The shape of the original array\",votes_raw_array.shape)\n",
        "print(\"\\n\",votes_raw_array)\n",
        "\n",
        "print(\"\\n\\n\") # Looks better :p\n",
        "\n",
        "print(\"The shape of the merged array\",merged_votes_array.shape)\n",
        "print(\"\\n\",merged_votes_array)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8I7BoW0IoAYq",
        "outputId": "83fee366-6dd6-483c-edf3-863985f69fef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The shape of the original array (92,)\n",
            "\n",
            " [33818 29479   654  1185 10761  8550   628   486 10599  8326   420   621\n",
            " 16592 13304   652   866  9299  7838   247   393  8358  6535   492   418\n",
            "  7431  5727   487   392  6228  4708   498   330  4964  3584   262   396\n",
            "  3069  2465    67   184  2755  2104   125   167  2379  1889    63   137\n",
            "  2378  1912    76   126  1810  1146   123   190  1671  1432    22    66\n",
            "  1649  1342    72    79  1357  1021    55    94  1287   920   132    69\n",
            "  1076   802    53    78   801   571    53    70   628   520     0    31\n",
            "     7   385    20    30 18105 15441   370   714]\n",
            "\n",
            "\n",
            "\n",
            "The shape of the merged array (23, 4)\n",
            "\n",
            " [[33818 29479   654  1185]\n",
            " [10761  8550   628   486]\n",
            " [10599  8326   420   621]\n",
            " [16592 13304   652   866]\n",
            " [ 9299  7838   247   393]\n",
            " [ 8358  6535   492   418]\n",
            " [ 7431  5727   487   392]\n",
            " [ 6228  4708   498   330]\n",
            " [ 4964  3584   262   396]\n",
            " [ 3069  2465    67   184]\n",
            " [ 2755  2104   125   167]\n",
            " [ 2379  1889    63   137]\n",
            " [ 2378  1912    76   126]\n",
            " [ 1810  1146   123   190]\n",
            " [ 1671  1432    22    66]\n",
            " [ 1649  1342    72    79]\n",
            " [ 1357  1021    55    94]\n",
            " [ 1287   920   132    69]\n",
            " [ 1076   802    53    78]\n",
            " [  801   571    53    70]\n",
            " [  628   520     0    31]\n",
            " [    7   385    20    30]\n",
            " [18105 15441   370   714]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Instead of having all this data in a single array, let's just divide the array into four parts"
      ],
      "metadata": {
        "id": "ihcaJ5IVzREJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "total_votes_array = merged_votes_array[:,0]\n",
        "professional_votes_array = merged_votes_array[:,1]\n",
        "beginner_votes_array = merged_votes_array[:,2]\n",
        "other_votes_array = merged_votes_array[:,3]\n",
        "\n",
        "print(\"Total votes array:\\n\",total_votes_array)\n",
        "print(\"\\n\\n\")\n",
        "print(\"Professional votes array:\\n\",professional_votes_array)\n",
        "print(\"\\n\\n\")\n",
        "print(\"Beginner votes array:\\n\",beginner_votes_array)\n",
        "print(\"\\n\\n\")\n",
        "print(\"Other votes array:\\n\",other_votes_array)\n",
        "print(\"\\n\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ej71GlPizfUA",
        "outputId": "d4b26ce7-f3c8-41cb-85ac-0fe613775f85"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total votes array:\n",
            " [33818 10761 10599 16592  9299  8358  7431  6228  4964  3069  2755  2379\n",
            "  2378  1810  1671  1649  1357  1287  1076   801   628     7 18105]\n",
            "\n",
            "\n",
            "\n",
            "Professional votes array:\n",
            " [29479  8550  8326 13304  7838  6535  5727  4708  3584  2465  2104  1889\n",
            "  1912  1146  1432  1342  1021   920   802   571   520   385 15441]\n",
            "\n",
            "\n",
            "\n",
            "Beginner votes array:\n",
            " [654 628 420 652 247 492 487 498 262  67 125  63  76 123  22  72  55 132\n",
            "  53  53   0  20 370]\n",
            "\n",
            "\n",
            "\n",
            "Other votes array:\n",
            " [1185  486  621  866  393  418  392  330  396  184  167  137  126  190\n",
            "   66   79   94   69   78   70   31   30  714]\n",
            "\n",
            "\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Slicing"
      ],
      "metadata": {
        "id": "obIbEclK-ffg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's discuss some basics about slicing in Python"
      ],
      "metadata": {
        "id": "ArDTj53m1OeZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l = [1,2,3,4,5]\n",
        "print(\"The first element of the list is\",l[0])\n",
        "print(\"Elements from second position to fourth position\",l[1:4]) # [included:excluded]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1ShVo4Ze1SJQ",
        "outputId": "d83bad74-8d0e-4f94-99ca-f56196d0c550"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The first element of the list is 1\n",
            "Elements from second position to fourth position [2, 3, 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In similar fasion we can also slice numpy arrays. Let's do it"
      ],
      "metadata": {
        "id": "fNvMh9gf2HvY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Corresponding vote values for a random cloud service\n",
        "print(\"Cloud service name:\",cloud_2023_array[:5])\n",
        "print(\"Total number of votes:\",total_votes_array[:5])\n",
        "print(\"Profession votes\",professional_votes_array[:5])\n",
        "print(\"Beginner votes:\",beginner_votes_array[:5])\n",
        "print(\"Other votes:\",other_votes_array[:5])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qAzh2VCR2NAg",
        "outputId": "1dd2884b-b152-456a-e2a5-de657610c5aa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloud service name: ['Amazon Web Services (AWS)' 'Firebase' 'Cloudflare' 'Google Cloud'\n",
            " 'Digital Ocean']\n",
            "Total number of votes: [33818 10761 10599 16592  9299]\n",
            "Profession votes [29479  8550  8326 13304  7838]\n",
            "Beginner votes: [654 628 420 652 247]\n",
            "Other votes: [1185  486  621  866  393]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note:\n",
        "\n",
        "\n",
        "\n",
        "*   If we do something like `cloud_2023_array[:4]` then we'll get the first four elements\n",
        "*   Slicing and changing the values affect the numpy array meanwhile it has no affect on python list\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "gj-ww-oj333C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# For example\n",
        "ls = [1,2,3,4,5]\n",
        "ls_arr = np.array(ls)\n",
        "\n",
        "ls[0:3][1] = 0\n",
        "ls_arr[0:3][1] = 0\n",
        "\n",
        "print(\"The list is\",ls)\n",
        "print(\"The array is\",ls_arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pe36a5hA7ZEb",
        "outputId": "779aecd8-bd71-4873-b269-2f968a3f6b6c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The list is [1, 2, 3, 4, 5]\n",
            "The array is [1 0 3 4 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "But we don't want that so we'll create a copy of the slice and store it in a different variable"
      ],
      "metadata": {
        "id": "XQ8c9p6B-T-Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ls_arr = np.array([1,2,3,4,5])\n",
        "even_index_elements_array = ls_arr[0:5:2].copy() # This is crucial\n",
        "print(\"Even index elements array is\",even_index_elements_array)\n",
        "# Now let's change something in the array and see whether those changes are refelected in the main array or not\n",
        "even_index_elements_array[0] = 2\n",
        "print(\"The original array\",ls_arr)\n",
        "print(\"The even index elements array\",even_index_elements_array)\n",
        "# So no changes to the original array"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i3uLY2QY-Z9X",
        "outputId": "524e576c-3672-4295-c929-3f0add7f488d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Even index elements array is [1 3 5]\n",
            "The original array [1 2 3 4 5]\n",
            "The even index elements array [2 3 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Vectorization in Numpy\n",
        "\n",
        "\n",
        "*   It is basically adding two arrays without the need of a manual loop in an user defined function\n",
        "*   Let's see the time difference\n",
        "\n"
      ],
      "metadata": {
        "id": "T0-Iwbi1BNMZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "def compute_non_professional_votes(beginner_votes_array,other_votes_array):\n",
        "    output = np.empty(len(beginner_votes_array)) # np.empty(size) - > Declares a empty numpy array of the given size\n",
        "    for i in range(len(beginner_votes_array)):\n",
        "        output[i] = beginner_votes_array[i] + other_votes_array[i]\n",
        "    return output\n",
        "\n",
        "%timeit compute_non_professional_votes(beginner_votes_array,other_votes_array)\n",
        "%timeit (beginner_votes_array,other_votes_array)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4IXW9M2B8XW",
        "outputId": "047fcacf-db1c-420c-e6f5-98e86fe38011"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10.8 µs ± 85.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
            "83.5 ns ± 18.8 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "*   As we can see that using vectorized addition is way more faster than manually looping using a user defined function.\n",
        "*   We will implement vectorization in numpy arrays using Ufuncs(Univesal functions)"
      ],
      "metadata": {
        "id": "rXpfGPYRD1se"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Original array:\\n\",beginner_votes_array)\n",
        "print(\"\\n\\n\")\n",
        "print(\"Adding 2 to all elements:\\n\",beginner_votes_array+2)\n",
        "# print(\"Adding 2 to all the elements:\\n\",np.add(beginner_votes_array,2)) # This will also be the same\n",
        "print(\"\\n\\n\")\n",
        "print(\"Dividing all elements by 2(floor):\\n\",beginner_votes_array//2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SjX-CxgcGSGP",
        "outputId": "cd82b34b-6fed-4387-89d9-a406626b792f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original array:\n",
            " [654 628 420 652 247 492 487 498 262  67 125  63  76 123  22  72  55 132\n",
            "  53  53   0  20 370]\n",
            "\n",
            "\n",
            "\n",
            "Adding 2 to all elements:\n",
            " [656 630 422 654 249 494 489 500 264  69 127  65  78 125  24  74  57 134\n",
            "  55  55   2  22 372]\n",
            "\n",
            "\n",
            "\n",
            "Dividing all elements by 2(floor):\n",
            " [327 314 210 326 123 246 243 249 131  33  62  31  38  61  11  36  27  66\n",
            "  26  26   0  10 185]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "non_professional_votes_array = beginner_votes_array + other_votes_array\n",
        "non_professional_votes_array_mean = round(np.mean(non_professional_votes_array),2) # rounding off till two decimal places\n",
        "print(\"The non professional votes array:\\n\",non_professional_votes_array)\n",
        "print(\"The non professional votes array mean:\\n\",non_professional_votes_array_mean)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8r7h9hhbIMsu",
        "outputId": "0c274164-df4b-4092-b67e-78bbad62d391"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The non professional votes array:\n",
            " [1839 1114 1041 1518  640  910  879  828  658  251  292  200  202  313\n",
            "   88  151  149  201  131  123   31   50 1084]\n",
            "The non professional votes array mean:\n",
            " 551.87\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "non_professional_votes_array>non_professional_votes_array_mean"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qpk5bPuyJWX_",
        "outputId": "0960b148-e5b9-4047-b1a5-873b3f060b4a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "       False, False, False, False, False, False, False, False, False,\n",
              "       False, False, False, False,  True])"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see if we use a condition with a numpy array, the program returns a boolean array (true -> at indexes whose value satisfies the condition and false -> at indexes whose value doesn't satisfies the condition)"
      ],
      "metadata": {
        "id": "pG3z5Jl3JcH1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.sum(non_professional_votes_array>non_professional_votes_array_mean)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DQXGQmr5K3s1",
        "outputId": "ac2cc418-bcce-4e73-edcf-7b4d46c6637a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "So this shows that 10 values are better than the average value.\n",
        "\n",
        "If we pass this boolean array to different array it'll print all the places where the valuer are true!"
      ],
      "metadata": {
        "id": "OtbXJXdMZFcS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Dominant cloud platforms:\\n\",cloud_2023_array[non_professional_votes_array>1000])\n",
        "# Dominant in the sense that their votes are greater than 1k"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fPOPIcllLZ9N",
        "outputId": "d4d1f159-6f42-40bf-ce14-5643a28e3d6f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dominant cloud platforms:\n",
            " ['Amazon Web Services (AWS)' 'Firebase' 'Cloudflare' 'Google Cloud'\n",
            " 'Microsoft Azure']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Are all cloud platforms greater than 1000 votes?\\n\",np.all(non_professional_votes_array>1000))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BUuGdZh1aa_D",
        "outputId": "bf566f90-894c-48fc-8232-67c3face144a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Are all cloud platforms greater than 1000 votes?\n",
            " False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This np.all(condition) function will give true only if all the values are true!"
      ],
      "metadata": {
        "id": "1jzbzfk3bTBY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Is there any cloud platform with more than 1000 votes?\\n\",np.any(non_professional_votes_array>1000))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iZvXMBGddChg",
        "outputId": "1c4ad7b1-7bbe-4c19-da01-db168b084856"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Is there any cloud platform with more than 1000 votes?\n",
            " True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This np.any(condition) function will give true when atleast one value is true.\n",
        "\n",
        "-> Boolean masking in NumPy refers to the process of using boolean arrays (arrays containing True and False values) to filter elements from another array. This technique allows you to extract, modify, or manipulate elements from an array based on a certain condition defined by a boolean array."
      ],
      "metadata": {
        "id": "wLcCw7v5ydgj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Concatenation"
      ],
      "metadata": {
        "id": "m6Y2qkF5y0-R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "new_cloud_platforms = np.array([\"ZohoCorpCloud\",\"MyCloudPlatform\"])\n",
        "updated_cloud_2023_array = np.concatenate([cloud_2023_array,new_cloud_platforms])\n",
        "print(\"The Updated cloud service list: \\n\",updated_cloud_2023_array)\n",
        "print(\"\\n\")\n",
        "print(\"The size of the Updated cloud service list:\",updated_cloud_2023_array.size)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w7ZJsk4Ky5Jh",
        "outputId": "2e4713cf-e9d2-4724-a8af-c50ffc48f0fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The Updated cloud service list: \n",
            " ['Amazon Web Services (AWS)' 'Firebase' 'Cloudflare' 'Google Cloud'\n",
            " 'Digital Ocean' 'Heroku' 'Vercel' 'Netlify' 'VMware' 'Hetzner'\n",
            " 'Linode, now Akamai' 'Managed Hosting' 'OVH'\n",
            " 'Oracle Cloud Infrastructure (OCI)' 'OpenShift' 'Fly.io' 'Vultr' 'Render'\n",
            " 'OpenStack' 'IBM Cloud Or Watson' 'Scaleway' 'Colocation'\n",
            " 'Microsoft Azure' 'ZohoCorpCloud' 'MyCloudPlatform']\n",
            "\n",
            "\n",
            "The size of the Updated cloud service list: 25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Some other useful stuff"
      ],
      "metadata": {
        "id": "V7vobeAfDkma"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "`np.add.reduce(array)`\n",
        "This is used to add-up all the elemnts of an array and reduce it to a single number"
      ],
      "metadata": {
        "id": "XZg5qGK-9x1y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Total number of voters in stack overflow\",np.add.reduce(total_votes_array))\n",
        "print(\"Total number of professional voters in stack overflow\",np.add.reduce(professional_votes_array))\n",
        "print(\"Total number of beginner voters in stack overflow\",np.add.reduce(beginner_votes_array))\n",
        "print(\"Total number of other voters in stack overflow\",np.add.reduce(other_votes_array))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ba2lM_248Ofk",
        "outputId": "577bd4d9-875e-478d-e117-7b0784156d6a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total number of voters in stack overflow 147022\n",
            "Total number of professional voters in stack overflow 120001\n",
            "Total number of beginner voters in stack overflow 5571\n",
            "Total number of other voters in stack overflow 7122\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "`np.min(array)` :- This function will give the minimum element from the array\n",
        "\n",
        "`np.max(array)` :- This function will give the maximum element from the array"
      ],
      "metadata": {
        "id": "lHMhNHFeDopy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"The maximum number of votes:\\n\",np.max(total_votes_array))\n",
        "print(\"The minimum number of votes:\\n\",np.min(total_votes_array))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jdl8z63hGy8Z",
        "outputId": "5245344f-ada6-405b-cae0-36d38737aa28"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The maximum number of votes:\n",
            " 33818\n",
            "The minimum number of votes:\n",
            " 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "But technically we don't have any use of this as we don't know who has the value is maximum and minimum\n",
        "\n",
        "To solve this we'll use\n",
        "\n",
        "```\n",
        "np.argmax(array) # For max index\n",
        "np.argmin(array) # For min index\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "yopw1kpGRGVU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "max_votes_index = np.argmax(total_votes_array)\n",
        "min_votes_index = np.argmin(total_votes_array)\n",
        "print(\"The index at the maxmimum votes is present:\\n\",max_votes_index)\n",
        "print(\"The index at the minimum votes is present:\\n\",min_votes_index)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AvccFPgLdL7l",
        "outputId": "65d7adb0-5bf2-4c45-bd0b-b23e53b2e5a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The index at the maxmimum votes is present:\n",
            " 0\n",
            "The index at the minimum votes is present:\n",
            " 21\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To make it look better we'll use f-strings concepts from python"
      ],
      "metadata": {
        "id": "8Wss_c-bfByj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"The maximum number of votes is {cloud_2023_array[max_votes_index]} with {total_votes_array[max_votes_index]} total votes\")\n",
        "print(f\"The minimum number of votes is {cloud_2023_array[min_votes_index]} with {total_votes_array[min_votes_index]} total votes\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zCdcOBJgfHDc",
        "outputId": "e526b78b-d439-4801-dbf1-bd50a9fffc29"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The maximum number of votes is Amazon Web Services (AWS) with 33818 total votes\n",
            "The minimum number of votes is Colocation with 7 total votes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we'll apply the logic for sorting using\n",
        "\n",
        "\n",
        "```\n",
        "np.sort(array)\n",
        "```\n",
        "\n",
        "this will return the sorted array\n",
        "\n",
        "For example:"
      ],
      "metadata": {
        "id": "3y3eyRjchdl1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "total_values_sorted = np.sort(total_votes_array)\n",
        "print(\"Sorted array of total votes\\n\",total_values_sorted)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aVE_hhe7hl4l",
        "outputId": "841ef0b8-3153-4a43-d6c5-ad650f10e537"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sorted array of total votes\n",
            " [    7   628   801  1076  1287  1357  1649  1671  1810  2378  2379  2755\n",
            "  3069  4964  6228  7431  8358  9299 10599 10761 16592 18105 33818]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "But we don't want it be sorted in terms of value, we want it to be sorted in terms of indexes and for that we'll use\n",
        "\n",
        "\n",
        "```\n",
        "np.argsort(array)\n",
        "```\n",
        "\n",
        "In this way we'll get an array which will contain the indexes of the array in sorted format\n",
        "\n",
        "For example:"
      ],
      "metadata": {
        "id": "IYPMErjxiE-p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sorted_indices_total = np.argsort(total_votes_array)\n",
        "print(\"(Asc)Sorted array of total votes's index:\\n\",sorted_indices_total)\n",
        "print(\"\\n\\n\")\n",
        "# If we want it to be reverse\n",
        "sorted_indices_total_dec = sorted_indices_total[::-1]\n",
        "print(\"(Dsc)Sorted array of total votes's index:\\n\",sorted_indices_total_dec)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L7wJvcmSiWus",
        "outputId": "913e0627-e104-4db8-cc88-388421986af1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(Asc)Sorted array of total votes's index:\n",
            " [21 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  2  1  3 22  0]\n",
            "\n",
            "\n",
            "\n",
            "(Dsc)Sorted array of total votes's index:\n",
            " [ 0 22  3  1  2  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This function returned an array which contains all the indexes in sorted from"
      ],
      "metadata": {
        "id": "BOUP1ZP7ikqF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cloud_2023_sorted = [cloud_2023_array[i] for i in sorted_indices_total_dec] # [array[i] for i in index_array]\n",
        "print(cloud_2023_sorted)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z05Gz3nVlh18",
        "outputId": "7caf12c1-e752-4ab2-a227-0afc64236499"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Amazon Web Services (AWS)', 'Microsoft Azure', 'Google Cloud', 'Firebase', 'Cloudflare', 'Digital Ocean', 'Heroku', 'Vercel', 'Netlify', 'VMware', 'Hetzner', 'Linode, now Akamai', 'Managed Hosting', 'OVH', 'Oracle Cloud Infrastructure (OCI)', 'OpenShift', 'Fly.io', 'Vultr', 'Render', 'OpenStack', 'IBM Cloud Or Watson', 'Scaleway', 'Colocation']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now let's learn about partial sorting\n",
        "\n",
        "\n",
        "\n",
        "*   Sorting is a very resource intensive task\n",
        "*   If we don't need the whole array to be sorted we'll use partial sorting which will reduce the load while maintaing the Usability\n",
        "\n"
      ],
      "metadata": {
        "id": "zcBFFXDBn3m0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "partial_sort_indexes = np.argpartition(total_votes_array,4)\n",
        "print(partial_sort_indexes) # bottom four cloud platforms (The first four)\n",
        "cloud_2023_partially_sorted = [cloud_2023_array[i] for i in partial_sort_indexes[:4]]\n",
        "print(\"The bottom four cloud platforms are (least->less)\\n\",cloud_2023_partially_sorted)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mpPuHr3Lop6h",
        "outputId": "1570ab56-fc4d-4b3b-f671-252ecab43a27"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[21 20 19 18 17  5  6  7  8 10 11  4 12 13 14 15 16  9  2  3  1 22  0]\n",
            "The bottom four cloud platforms are (least->less)\n",
            " ['Colocation', 'Scaleway', 'IBM Cloud Or Watson', 'OpenStack']\n"
          ]
        }
      ]
    }
  ]
}