Assignment_1(Numpy_Fundamentals).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Assignment#1(Numpy Fundamentals).ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3.9.0 64-bit",
      "metadata": {
        "interpreter": {
          "hash": "7b1848f6e040d0284a330bddb5bfb0c0225bd24997ff60f194dcf3e4111bf672"
        }
      }
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.0-final"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NgUeapcvmIRh"
      },
      "source": [
        "# **Assignment For Numpy**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yhr3JicwnA-4"
      },
      "source": [
        "Difficulty Level **Beginner**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hVPqDJ1SnKSh"
      },
      "source": [
        "1. Import the numpy package under the name np"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SePu31zKmgS-"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d0gO81krnL7g"
      },
      "source": [
        "2. Create a null vector of size 10 "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2s6o2JPgnSBr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9df276ae-8748-484e-a638-b74233d52354"
      },
      "source": [
        "np.zeros(10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BJTMK03fnS1w"
      },
      "source": [
        "3. Create a vector with values ranging from 10 to 49"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qRXxXuWdnj1M",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "efd4b712-6ab9-4a2f-c6be-cb4c035a5875"
      },
      "source": [
        "x = np.arange(10,50)\r\n",
        "x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n",
              "       27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,\n",
              "       44, 45, 46, 47, 48, 49])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n63lzg5Onkcn"
      },
      "source": [
        "4. Find the shape of previous array in question 3"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1FueBdqPn_q7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d531eb86-1beb-4b50-dd0d-6c80f080315b"
      },
      "source": [
        "np.shape(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AzMlQj1MoAVe"
      },
      "source": [
        "5. Print the type of the previous array in question 3"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AO9PYmdWoE1L",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ec656d22-52d6-48e2-9a5b-8ce264feb469"
      },
      "source": [
        "x.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('int64')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0qaKS13Yon-U"
      },
      "source": [
        "6. Print the numpy version and the configuration\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T3wY24e1oorh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a97597e2-d32b-4f5f-af62-889b6530e6cf"
      },
      "source": [
        "np.__version__\r\n",
        "np.show_config()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "blas_mkl_info:\n",
            "  NOT AVAILABLE\n",
            "blis_info:\n",
            "  NOT AVAILABLE\n",
            "openblas_info:\n",
            "    libraries = ['openblas', 'openblas']\n",
            "    library_dirs = ['/usr/local/lib']\n",
            "    language = c\n",
            "    define_macros = [('HAVE_CBLAS', None)]\n",
            "blas_opt_info:\n",
            "    libraries = ['openblas', 'openblas']\n",
            "    library_dirs = ['/usr/local/lib']\n",
            "    language = c\n",
            "    define_macros = [('HAVE_CBLAS', None)]\n",
            "lapack_mkl_info:\n",
            "  NOT AVAILABLE\n",
            "openblas_lapack_info:\n",
            "    libraries = ['openblas', 'openblas']\n",
            "    library_dirs = ['/usr/local/lib']\n",
            "    language = c\n",
            "    define_macros = [('HAVE_CBLAS', None)]\n",
            "lapack_opt_info:\n",
            "    libraries = ['openblas', 'openblas']\n",
            "    library_dirs = ['/usr/local/lib']\n",
            "    language = c\n",
            "    define_macros = [('HAVE_CBLAS', None)]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZyUUiQf5oyvE"
      },
      "source": [
        "7. Print the dimension of the array in question 3\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pLXfuIqIo0vq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15639628-4a2b-439d-8887-6cabccadd6f5"
      },
      "source": [
        "x.ndim"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JYVMuFrqpBdV"
      },
      "source": [
        "8. Create a boolean array with all the True values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3apZsISzpFKR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ce711ad9-33c3-43dc-cdd4-b17266d0c946"
      },
      "source": [
        "True_values = (x>0)\r\n",
        "True_values"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
              "        True,  True,  True,  True])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4zbBooWZpPBU"
      },
      "source": [
        "9. Create a two dimensional array\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KfPQEiVIpdTo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ae5fe8ff-b78e-4570-de7e-2de2cdbe3de5"
      },
      "source": [
        "y = np.arange(20).reshape(4,5)\n",
        "print(y)\n",
        "y.ndim"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 0  1  2  3  4]\n [ 5  6  7  8  9]\n [10 11 12 13 14]\n [15 16 17 18 19]]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "do9wPAFbpqC7"
      },
      "source": [
        "10. Create a three dimensional array\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZCO_q-KZqAeW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3d5c7e8-0cd9-470c-888d-5d655fe6364c"
      },
      "source": [
        "y = np.arange(27).reshape(3,3,3)\n",
        "print(y)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[ 0  1  2]\n  [ 3  4  5]\n  [ 6  7  8]]\n\n [[ 9 10 11]\n  [12 13 14]\n  [15 16 17]]\n\n [[18 19 20]\n  [21 22 23]\n  [24 25 26]]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a4iysJ87qEeb"
      },
      "source": [
        "Difficulty Level **Easy**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DehgqszSqjY6"
      },
      "source": [
        "11. Reverse a vector (first element becomes last)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tfevmc4VqkWu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "830d2f07-c718-4ce3-f8d9-44446772e514"
      },
      "source": [
        "np.flip(y)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[26, 25, 24],\n",
              "        [23, 22, 21],\n",
              "        [20, 19, 18]],\n",
              "\n",
              "       [[17, 16, 15],\n",
              "        [14, 13, 12],\n",
              "        [11, 10,  9]],\n",
              "\n",
              "       [[ 8,  7,  6],\n",
              "        [ 5,  4,  3],\n",
              "        [ 2,  1,  0]]])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yoATXS-qqk_q"
      },
      "source": [
        "12. Create a null vector of size 10 but the fifth value which is 1 "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AheZ32Owqpte",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9692fecc-9027-4ba0-8ec6-567fd1e95bdb"
      },
      "source": [
        "z = np.zeros(10)\r\n",
        "print(z)\r\n",
        "z[4] = 1\r\n",
        "print(z) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RZRzOBbFsY0w"
      },
      "source": [
        "13. Create a 3x3 identity matrix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "va2ou0BHsvEj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "689a3275-b113-4694-8581-8c28c7ff5522"
      },
      "source": [
        "np.identity(3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 0., 0.],\n",
              "       [0., 1., 0.],\n",
              "       [0., 0., 1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lnN5drkUs6o2"
      },
      "source": [
        "14. arr = np.array([1, 2, 3, 4, 5]) \n",
        "\n",
        "---\n",
        "\n",
        " Convert the data type of the given array from int to float "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "59EIQt6otKUB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "35811e6f-969d-4991-ef03-ca461a6fed31"
      },
      "source": [
        "arr = np.array([1, 2, 3, 4, 5]) \n",
        "float_arr = arr.astype(np.float64)\n",
        "float_arr"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1., 2., 3., 4., 5.])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fSL2AKJetTes"
      },
      "source": [
        "15. arr1 =          np.array([[1., 2., 3.],\n",
        "\n",
        "                    [4., 5., 6.]])  \n",
        "                      \n",
        "    arr2 = np.array([[0., 4., 1.],\n",
        "     \n",
        "                   [7., 2., 12.]])\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Multiply arr1 with arr2\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7VDXgRQDuJNV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0ccdf48a-871f-4c0d-8388-ccd814ebdd99"
      },
      "source": [
        "arr1 = np.array([[1., 2., 3.],\r\n",
        "                 [4., 5., 6.]])\r\n",
        "arr2 = np.array([[0., 4., 1.],\r\n",
        "                 [7., 2., 12.]])\r\n",
        "arr1 * arr2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0.,  8.,  3.],\n",
              "       [28., 10., 72.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a8yJ438-uKni"
      },
      "source": [
        "16. arr1 = np.array([[1., 2., 3.],\n",
        "                    [4., 5., 6.]]) \n",
        "                    \n",
        "    arr2 = np.array([[0., 4., 1.], \n",
        "                    [7., 2., 12.]])\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "Make an array by comparing both the arrays provided above"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3MPDaAlYueF3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8ba99ecd-1b48-4789-cd85-7d5b27ca95e9"
      },
      "source": [
        "array = (arr1>arr2)\r\n",
        "array"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ True, False,  True],\n",
              "       [False,  True, False]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3xiD0eJluewk"
      },
      "source": [
        "17. Extract all odd numbers from arr with values(0-9)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J_qbt_EuvM7l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "960b5124-29d4-40e6-f00e-65a9038a64b3"
      },
      "source": [
        "arr = np.arange(9)\r\n",
        "odd_arr = arr[arr%2 != 0]\r\n",
        "odd_arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 3, 5, 7])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zpg5cyLsvPoZ"
      },
      "source": [
        "18. Replace all odd numbers to -1 from previous array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rXUV1-ULvQdd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "52e27409-3954-4c2f-b9fe-4b4b453006fa"
      },
      "source": [
        "arr[arr%2 != 0] = -1\r\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0, -1,  2, -1,  4, -1,  6, -1,  8])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FWpHTWTDvjvi"
      },
      "source": [
        "19. arr = np.arange(10)\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "Replace the values of indexes 5,6,7 and 8 to **12**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ensZ3lqwvlSb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a81351d1-04db-42a4-aed6-cbaf6831839f"
      },
      "source": [
        "arr = np.arange(10)\r\n",
        "np.put(arr, [5, 6, 7], [8,10, 12])\r\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0,  1,  2,  3,  4,  8, 10, 12,  8,  9])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ib-vBffAv0zy"
      },
      "source": [
        "20. Create a 2d array with 1 on the border and 0 inside"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RmzcjNYrwDrM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f9ff74e9-630b-40d3-e326-6b5aeb333ebf"
      },
      "source": [
        "arr = np.ones((5,5))\r\n",
        "arr\r\n",
        "arr[1:-1, 1:-1] = 0\r\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1., 1., 1., 1.],\n",
              "       [1., 0., 0., 0., 1.],\n",
              "       [1., 0., 0., 0., 1.],\n",
              "       [1., 0., 0., 0., 1.],\n",
              "       [1., 1., 1., 1., 1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E1diIFSEwEmh"
      },
      "source": [
        "Difficulty Level **Medium**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eGLZmNb_wKb4"
      },
      "source": [
        "21. arr2d = np.array([[1, 2, 3],\n",
        "\n",
        "                    [4, 5, 6], \n",
        "\n",
        "                    [7, 8, 9]])\n",
        "\n",
        "---\n",
        "\n",
        "Replace the value 5 to 12"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VdUnsUOZwJFz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cbfab307-0c3b-4494-ac82-40624037f2f9"
      },
      "source": [
        "arr2d = np.array([[1, 2, 3],\r\n",
        "                  [4, 5, 6],\r\n",
        "                  [7, 8, 9]])\r\n",
        "arr2d[1,-2] = 12\r\n",
        "arr2d"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  2,  3],\n",
              "       [ 4, 12,  6],\n",
              "       [ 7,  8,  9]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TEbFhlPZxaKO"
      },
      "source": [
        "22. arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
        "\n",
        "---\n",
        "Convert all the values of 1st array to 64\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eYzephU8xmsg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "51df0f19-5d4c-4402-f92d-5826d532ee26"
      },
      "source": [
        "arr3d = np.array([[[1, 2, 3],\r\n",
        "                   [4, 5, 6]],\r\n",
        "                  \r\n",
        "                   [[7, 8, 9],\r\n",
        "                    [10, 11, 12]]])\r\n",
        "arr3d[0,0] = 64\r\n",
        "arr3d\r\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[64, 64, 64],\n",
              "        [ 4,  5,  6]],\n",
              "\n",
              "       [[ 7,  8,  9],\n",
              "        [10, 11, 12]]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vZj0Ndvnx6f0"
      },
      "source": [
        "23. Make a 2-Dimensional array with values 0-9 and slice out the first 1st 1-D array from it"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pM4e9YfdyHSv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9170921b-acf6-4e2e-9d8e-731e843cac8a"
      },
      "source": [
        "arr = np.array([[ 1,  2,  3],\r\n",
        "                [ 4,  5,  6],\r\n",
        "                [ 7,  8,  9]])\r\n",
        "arr[0:1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C3dkW0lZyVps"
      },
      "source": [
        "24. Make a 2-Dimensional array with values 0-9 and slice out the 2nd value from 2nd 1-D array from it"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IrrzK2xgygqV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6ac4f479-29ae-4ce9-b727-b67ac8d9c9e6"
      },
      "source": [
        "arr = np.array([[ 1,  2,  3],\r\n",
        "                [ 4,  5,  6],\r\n",
        "                [ 7,  8,  9]])\r\n",
        "arr[1:2, 1:2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[5]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G3dLwOO9yyrE"
      },
      "source": [
        "25. Make a 2-Dimensional array with values 0-9 and slice out the third column but only the first two rows"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Bx4fqsLyqGD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d6e55f38-19a9-415f-93d8-c18c6e148168"
      },
      "source": [
        "arr = np.array([[ 1,  2,  3],\r\n",
        "                [ 4,  5,  6],\r\n",
        "                [ 7,  8,  9]])\r\n",
        "arr[:2, -1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3, 6])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CQ9YST5jy0IL"
      },
      "source": [
        "26. Create a 10x10 array with random values and find the minimum and maximum values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lhJPugjQzG6W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b77bb607-f54a-4ff4-a9cc-c2ba2f325beb"
      },
      "source": [
        "tenbyten = np.random.rand(10,10)*10\n",
        "tenbyten = tenbyten.astype(np.int)\n",
        "print(tenbyten)\n",
        "print(tenbyten.min())\n",
        "print(tenbyten.max())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0.88270897 0.81377535 0.93428773 0.63743862 0.64374566 0.98227216\n",
            "  0.41854843 0.23075533 0.20452323 0.49112565]\n",
            " [0.7618714  0.2146083  0.50283639 0.22096642 0.32889331 0.66546054\n",
            "  0.9304121  0.9604145  0.05381254 0.02312963]\n",
            " [0.87692342 0.5715093  0.74183112 0.46154822 0.45177061 0.99462118\n",
            "  0.2678483  0.7230203  0.54334152 0.25144342]\n",
            " [0.18245768 0.62247178 0.05098295 0.30500437 0.68485855 0.8550841\n",
            "  0.64894091 0.01219123 0.408369   0.1808719 ]\n",
            " [0.18066876 0.00605425 0.98358246 0.46613881 0.95166994 0.74844309\n",
            "  0.72086417 0.11223808 0.45588832 0.08608523]\n",
            " [0.328427   0.54334891 0.07734359 0.9290117  0.81832865 0.1660457\n",
            "  0.35182176 0.98254741 0.78192804 0.28465646]\n",
            " [0.19806648 0.21942487 0.6156832  0.8248799  0.1436961  0.00224598\n",
            "  0.00740019 0.53908491 0.49959456 0.20918241]\n",
            " [0.49764332 0.11775644 0.05711771 0.98750196 0.8018041  0.40599867\n",
            "  0.09561804 0.41479862 0.98476983 0.27639814]\n",
            " [0.58043365 0.29829408 0.02965475 0.56324949 0.08011577 0.53919114\n",
            "  0.45718757 0.98804888 0.69623175 0.07253237]\n",
            " [0.43259265 0.66229013 0.2829663  0.02233745 0.54352294 0.63696081\n",
            "  0.38454806 0.24571965 0.93765967 0.98084815]]\n",
            "0.0022459833728830647\n",
            "0.9946211819220602\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cAgDt6KazHk6"
      },
      "source": [
        "27. a = np.array([1,2,3,2,3,4,3,4,5,6]) b = np.array([7,2,10,2,7,4,9,4,9,8])\n",
        "---\n",
        "Find the common items between a and b\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kBXZanxIzs_F",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cdb2a6c3-8af0-4016-9972-e0cd6009f9bd"
      },
      "source": [
        "a = np.array([1,2,3,2,3,4,3,4,5,6]) \r\n",
        "b = np.array([7,2,10,2,7,4,9,4,9,8])\r\n",
        "\r\n",
        "print(np.intersect1d(a, b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lF9IzWOAztpD"
      },
      "source": [
        "28. a = np.array([1,2,3,2,3,4,3,4,5,6])\n",
        "b = np.array([7,2,10,2,7,4,9,4,9,8])\n",
        "\n",
        "---\n",
        "Find the positions where elements of a and b match\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JR-mHQLH0HY_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e73a1340-3357-4d2b-9861-cc3e98dcd357"
      },
      "source": [
        "a = np.array([1,2,3,2,3,4,3,4,5,6]) \r\n",
        "b = np.array([7,2,10,2,7,4,9,4,9,8])\r\n",
        "np.where(np.in1d(a, b))[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 3, 5, 7])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mMDiefpH0H1x"
      },
      "source": [
        "29.  names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])  data = np.random.randn(7, 4)\n",
        "\n",
        "---\n",
        "Find all the values from array **data** where the values from array **names** are not equal to **Will**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gfc1Lpf81ZSR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "46d37218-6df3-4703-a622-da6ea98c81b4"
      },
      "source": [
        "names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\r\n",
        "data = np.random.randn(7, 4)\r\n",
        "print(data[names != \"Will\"])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[-0.57395979 -1.11857017 -1.14044117 -0.94536126]\n",
            " [-0.15795819 -1.25477587 -1.54067382  0.48647293]\n",
            " [ 0.94942004  1.46064645  0.04808791 -0.44942913]\n",
            " [ 0.86966837  0.13657585  0.44597971  0.37190827]\n",
            " [ 1.39870196 -0.49873079  0.19826796  0.13134049]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "52zEjDMf1aXS"
      },
      "source": [
        "30. names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe']) data = np.random.randn(7, 4)\n",
        "\n",
        "---\n",
        "Find all the values from array **data** where the values from array **names** are not equal to **Will** and **Joe**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8RYG0kLO1mHw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ae57f947-c15f-4329-e50e-30579a39f98b"
      },
      "source": [
        "names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe']) \n",
        "data = np.random.randn(7, 4)\n",
        "\n",
        "data[names==\"Bob\"] "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1.45370658, -0.1039462 , -1.07309308, -0.05238025],\n",
              "       [-0.90518323,  0.18450549,  1.16012525, -0.50645688]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q7hjf2bd2dCY"
      },
      "source": [
        "Difficulty Level **Hard**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b48g7aRA2jVM"
      },
      "source": [
        "31. Create a 2D array of shape 5x3 to contain decimal numbers between 1 and 15."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EbwfSCrW2f9_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c5b6916e-1685-440e-e36f-0f78ca0569ef"
      },
      "source": [
        "arr = np.arange(1, 16)\r\n",
        "arr = arr.reshape(5,3)\r\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  2,  3],\n",
              "       [ 4,  5,  6],\n",
              "       [ 7,  8,  9],\n",
              "       [10, 11, 12],\n",
              "       [13, 14, 15]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 112
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ei_nDHtO3qBk"
      },
      "source": [
        "32. Create an array of shape (2, 2, 4) with decimal numbers between 1 to 16."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "phOxVpBM4M6D",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5e7416f-4b93-4c2d-af96-a6279aea01ff"
      },
      "source": [
        "arr = np.arange(1, 17)\r\n",
        "arr = arr.reshape(2, 2, 4)\r\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[ 1,  2,  3,  4],\n",
              "        [ 5,  6,  7,  8]],\n",
              "\n",
              "       [[ 9, 10, 11, 12],\n",
              "        [13, 14, 15, 16]]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uyiQaMjA4d_x"
      },
      "source": [
        "33. Swap axes of the array you created in Question 32"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w2m9p8064VtR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b7f7a6d9-80ae-476d-9baf-e16c3ed904da"
      },
      "source": [
        "arr = np.swapaxes(arr,0,2)\r\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[ 1,  9],\n",
              "        [ 5, 13]],\n",
              "\n",
              "       [[ 2, 10],\n",
              "        [ 6, 14]],\n",
              "\n",
              "       [[ 3, 11],\n",
              "        [ 7, 15]],\n",
              "\n",
              "       [[ 4, 12],\n",
              "        [ 8, 16]]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 118
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2dlU_yUR4mVZ"
      },
      "source": [
        "34. Create an array of size 10, and find the square root of every element in the array, if the values less than 0.5, replace them with 0"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tmBabEJ-5JgB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07f9188c-4452-4fd3-fb5f-1ccd5dbd2a1b"
      },
      "source": [
        "y = np.random.rand(10)\n",
        "z = np.sqrt(y)\n",
        "print(z)\n",
        "np.where(z<0.5, 0, z)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.78449372 0.69741378 0.71766791 0.86991371 0.95996902 0.42091269\n 0.9303177  0.80873896 0.67404363 0.86049132]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.78449372, 0.69741378, 0.71766791, 0.86991371, 0.95996902,\n",
              "       0.        , 0.9303177 , 0.80873896, 0.67404363, 0.86049132])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SNAM4dpu5RKA"
      },
      "source": [
        "35. Create two random arrays of range 12 and make an array with the maximum values between each element of the two arrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3pxebU2b5q9Z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cb07b62a-5608-4b9e-da2d-a4965f4cc281"
      },
      "source": [
        "x = np.random.rand(12)\r\n",
        "y = np.random.rand(12)\r\n",
        "\r\n",
        "z = np.maximum(x, y)\r\n",
        "print(z)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.50021824 0.51397227 0.91727017 0.56812108 0.66279079 0.44245229\n",
            " 0.61591602 0.47881123 0.67382576 0.46528722 0.57394795 0.86820209]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fz_bpqm28qmD"
      },
      "source": [
        "36. names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\n",
        "\n",
        "---\n",
        "Find the unique names and sort them out!\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hiSNMgcY87Ey",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "28429e0b-33f0-44d1-9b8f-15a09251f870"
      },
      "source": [
        "names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\r\n",
        "np.unique(names)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['Bob', 'Joe', 'Will'], dtype='<U4')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dguMNzob870H"
      },
      "source": [
        "37. a = np.array([1,2,3,4,5])\n",
        "b = np.array([5,6,7,8,9])\n",
        "\n",
        "---\n",
        "From array a remove all items present in array b\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eCNJXPvK9IAr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9b31c5ea-1444-4438-ca20-2717c5b0b083"
      },
      "source": [
        "a = np.array([1,2,3,4,5])\r\n",
        "b = np.array([5,6,7,8,9])\r\n",
        "np.setdiff1d(a, b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gz4Dvd4b_Akh"
      },
      "source": [
        "38.  Following is the input NumPy array delete column two and insert following new column in its place.\n",
        "\n",
        "---\n",
        "sampleArray = numpy.array([[34,43,73],[82,22,12],[53,94,66]]) \n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "newColumn = numpy.array([[10,10,10]])\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lLWAJWJJ_I3d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f801d120-2db0-483e-8b4a-068db1d725b2"
      },
      "source": [
        "sampleArray = np.array([[34,43,73],[82,22,12],[53,94,66]]) \r\n",
        "newColumn = np.array([[10,10,10]])\r\n",
        "newColumn.shape = (3, 1)\r\n",
        "\r\n",
        "sampleArray = np.delete(sampleArray, 1, 1)\r\n",
        "sampleArray = np.hstack((sampleArray[:,:1], newColumn, sampleArray[:,1:]))\r\n",
        "print(sampleArray)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[34 10 73]\n",
            " [82 10 12]\n",
            " [53 10 66]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1lIfmbQt_J_W"
      },
      "source": [
        "39. x = np.array([[1., 2., 3.], [4., 5., 6.]]) y = np.array([[6., 23.], [-1, 7], [8, 9]])\n",
        "\n",
        "\n",
        "---\n",
        "Find the dot product of the above two matrix\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fV2-vXcR_vmu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b3013ddc-fd2a-4528-c2b3-e5ebad13f9ec"
      },
      "source": [
        "x = np.array([[1., 2., 3.], [4., 5., 6.]])\r\n",
        "y = np.array([[6., 23.], [-1, 7], [8, 9]])\r\n",
        "np.dot(x,y, out = None)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 28.,  64.],\n",
              "       [ 67., 181.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5U-4odUw_wP0"
      },
      "source": [
        "40. Generate a matrix of 20 random values and find its cumulative sum"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_oOHdiYEAF8N",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f15ef950-2dfa-4550-beaa-79bcf5f446c8"
      },
      "source": [
        "x = np.random.rand(20)\n",
        "print(x)\n",
        "print(np.cumsum(x))"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.8509572  0.90412678 0.77508281 0.03475663 0.32631415 0.03872501\n 0.85320174 0.92637796 0.91053861 0.36852871 0.17719623 0.54387065\n 0.58562911 0.42560147 0.28376719 0.7392943  0.4918553  0.01227775\n 0.44491809 0.2515149 ]\n[0.8509572  1.75508397 2.53016678 2.56492341 2.89123757 2.92996257\n 3.78316431 4.70954227 5.62008088 5.98860959 6.16580582 6.70967647\n 7.29530557 7.72090705 8.00467424 8.74396853 9.23582384 9.24810158\n 9.69301967 9.94453458]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ux08dfCWX8cC"
      },
      "source": [],
      "execution_count": null,
      "outputs": []
    }
  ]
}