Numpy.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hYtl6uCPGrW8"
      },
      "source": [
        "# **NUMPY**\n",
        "NumPy is a powerful Python library for numerical computing. It provides support for large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays efficiently. Here are some key features and concepts of NumPy:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "FOvb5kxlmYkP"
      },
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CiPdzcSNHjmz"
      },
      "source": [
        "The arange() function is used to create an array with regularly spaced values within a specified range."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ci7r10W8m8Ui",
        "outputId": "b58988b4-9fef-4459-d19e-8508151d914e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.arange(2, 10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a8F2O872nLl0",
        "outputId": "e8f15e82-c680-4ee3-a0c4-9505f3f6537b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([10,  9,  8,  7,  6,  5,  4,  3])"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.arange(10, 2, -1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LrTKAVsIH-Ni"
      },
      "source": [
        "The linspace() function is used to create an array with a specified number of evenly spaced values within a specified range. Unlike arange(), which generates values based on a step size, linspace() generates values based on the number of elements desired in the output array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rwl68VNinVWK",
        "outputId": "e9567fbb-43ba-45f1-d3e6-597a4ce141f6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 0.        ,  1.11111111,  2.22222222,  3.33333333,  4.44444444,\n",
              "        5.55555556,  6.66666667,  7.77777778,  8.88888889, 10.        ])"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.linspace(0, 10, 10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hpRH1RTRNhL9"
      },
      "source": [
        " The logspace() function is used to create an array with a specified number of logarithmically spaced values within a specified range. It is similar to the linspace() function, but instead of generating evenly spaced values, logspace() generates values that are evenly spaced on a logarithmic scale."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nM9xcOB07MjM",
        "outputId": "8d62a27a-d93c-4e73-f8a0-5eb17dad5be0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([  100.        ,   193.06977289,   372.75937203,   719.685673  ,\n",
              "        1389.49549437,  2682.69579528,  5179.47467923, 10000.        ])"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.logspace(2, 4, 8)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gOlB7jNmN0WQ"
      },
      "source": [
        "The random module provides various functions for generating random numbers and random arrays. These functions allow you to generate random values from different probability distributions, as well as random arrays of specified shapes and sizes. Here are a few commonly used functions from the random module:\n",
        "\n",
        "rand(): This function generates random numbers from a uniform distribution over the range [0, 1]. It returns an array or a single random value.\n",
        "\n",
        "randint(): This function generates random integers from a specified range. The range is inclusive of the lower bound and exclusive of the upper bound.\n",
        "\n",
        "random(): This function generates random numbers from a continuous uniform distribution over the range [0, 1]. It returns an array or a single random value.\n",
        "\n",
        "randn(): This function generates random numbers from a standard normal distribution (mean 0, standard deviation 1).\n",
        "\n",
        "choice(): This function randomly selects elements from a given array with replacement."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0x5SNH2E9LKK",
        "outputId": "21f267e8-38a0-470b-85d5-e0889e8a1643"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([3, 9, 6, 9, 1])"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.random.randint(1, 10, 5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pLivaTB4LFqy",
        "outputId": "94649c5b-2235-49e3-d610-4d49a19d2985"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[5, 5, 7, 3, 1, 1]\n",
            "[9, 1, 6, 9, 4, 6]\n",
            "[6, 3, 1, 8, 5, 4]\n",
            "[4, 9, 4, 5, 9, 8]\n",
            "[4, 4, 3, 6, 5, 8]\n",
            "[5, 3, 5, 7, 3, 7]\n",
            "[4, 4, 9, 5, 6, 7]\n",
            "[6, 3, 3, 4, 9, 5]\n"
          ]
        }
      ],
      "source": [
        "column = 6\n",
        "rows = 8\n",
        "patterns = [[np.random.randint(1, 10) for i in range (column)]  for j in range (rows)]\n",
        "for rows in patterns:\n",
        "  print(rows)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "l15Gub6VAbdJ"
      },
      "outputs": [],
      "source": [
        "# in simple way\n",
        "d = np.random.randint(1, 10, size=(6, 6))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XCVK8vWQECzJ",
        "outputId": "9bdf4d97-d298-4d32-a796-33116559a854"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[5, 2, 4, 9, 8, 6],\n",
              "       [4, 6, 9, 9, 7, 6],\n",
              "       [4, 1, 5, 5, 9, 1],\n",
              "       [5, 2, 5, 3, 1, 3],\n",
              "       [8, 7, 7, 8, 2, 9],\n",
              "       [8, 8, 6, 5, 8, 9]])"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rtEkXLaHOyPv"
      },
      "source": [
        "**INDEXING**:\n",
        "\n",
        "Indexing in NumPy allows you to access specific elements or subsets of elements in an array. You can use indexing to retrieve individual elements, rows, columns, or subarrays based on their positions or conditions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EMR88gVDEQbV",
        "outputId": "62fac403-fda5-46d1-a045-24ce2b56f342"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[5, 2, 4, 9, 8, 6],\n",
              "       [4, 6, 9, 9, 7, 6],\n",
              "       [4, 1, 5, 5, 9, 1],\n",
              "       [5, 2, 5, 3, 1, 3],\n",
              "       [8, 7, 7, 8, 2, 9],\n",
              "       [8, 8, 6, 5, 8, 9]])"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d[:,:]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VZe4z-iSEtvm",
        "outputId": "b99c1616-8b3c-4cbe-d441-acf34400c3a9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[4, 9, 8],\n",
              "       [9, 9, 7],\n",
              "       [5, 5, 9],\n",
              "       [5, 3, 1],\n",
              "       [7, 8, 2],\n",
              "       [6, 5, 8]])"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d[:,2:5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oXvrbQawEzVk",
        "outputId": "4a8bd94f-0f8e-4b8e-b6d5-cc3e4b4442d9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([9, 9, 5, 3, 8, 5])"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d[:,3]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wkhAg8YgE5UO",
        "outputId": "2d2ec4cf-31e9-46f2-fbac-770784b0904f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[9, 9, 7, 6],\n",
              "       [5, 5, 9, 1],\n",
              "       [5, 3, 1, 3]])"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d[1:4,2:6]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "RH229RbTFQkx"
      },
      "outputs": [],
      "source": [
        "a = np.ones((4,4))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FyTAmkvNPVL_",
        "outputId": "1a2b3790-b211-4ac6-ddbd-ded3331cddbd"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1.]])"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "a"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "iDcqw6ApPjlq"
      },
      "outputs": [],
      "source": [
        "b = np.zeros((4,4))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QhQW692cX7af",
        "outputId": "ec72799a-05e3-4f54-d43c-05e91709859c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.]])"
            ]
          },
          "execution_count": 18,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "b"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J_ZvUL7FYfx0"
      },
      "source": [
        "**Concatenation**:\n",
        "The concatenate() function is used to join two or more arrays along a specified axis. It allows you to combine arrays either vertically (along rows) or horizontally (along columns). The arrays being concatenated must have the same shape in all dimensions, except the one along which they are being concatenated."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mkwrpOO3YBwY",
        "outputId": "bf2b02d9-50c0-4843-cdda-26d2c953f6dc"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1.],\n",
              "       [0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.]])"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.concatenate([a, b])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-GsaZ6eXYHHh",
        "outputId": "e619797e-77eb-47bd-a614-b45da505aaba"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1., 1., 1., 1., 0., 0., 0., 0.],\n",
              "       [1., 1., 1., 1., 0., 0., 0., 0.],\n",
              "       [1., 1., 1., 1., 0., 0., 0., 0.],\n",
              "       [1., 1., 1., 1., 0., 0., 0., 0.]])"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# if axis = 1\n",
        "np.concatenate([a, b], axis = 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hN8YPrkpZEvt",
        "outputId": "1e426a3b-1a93-4410-fb2a-97bb4fcdd520"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1.],\n",
              "       [0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.]])"
            ]
          },
          "execution_count": 21,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# if axis = 0\n",
        "np.concatenate([a, b], axis = 0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wxJFUyRRcklD"
      },
      "source": [
        "**Split**:\n",
        "The split() function is used to split an array into multiple subarrays along a specified axis. It divides the array into equal-sized or nearly equal-sized parts and returns a list of subarrays."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RHBj7IZZZJrO",
        "outputId": "9dd0ccb5-4477-41db-b13a-f9d83307ae45"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[5, 2, 4, 9, 8, 6],\n",
              "       [4, 6, 9, 9, 7, 6],\n",
              "       [4, 1, 5, 5, 9, 1],\n",
              "       [5, 2, 5, 3, 1, 3],\n",
              "       [8, 7, 7, 8, 2, 9],\n",
              "       [8, 8, 6, 5, 8, 9]])"
            ]
          },
          "execution_count": 22,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D-IxjY49cBZb",
        "outputId": "36a6d44d-8ee4-483a-e10b-83c2d848bae0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[array([[5, 2, 4, 9, 8, 6],\n",
              "        [4, 6, 9, 9, 7, 6],\n",
              "        [4, 1, 5, 5, 9, 1]]),\n",
              " array([[5, 2, 5, 3, 1, 3],\n",
              "        [8, 7, 7, 8, 2, 9],\n",
              "        [8, 8, 6, 5, 8, 9]])]"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.split(d, 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z7Ro9nyidFxg"
      },
      "source": [
        "vsplit(): This function splits an array vertically into multiple subarrays by specifying the number of equally-sized parts or the indices at which to split the array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4VctyFL9cG-k",
        "outputId": "8225a873-cf08-48f8-fa8a-311df1d29c5e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[array([[5, 2, 4, 9, 8, 6],\n",
              "        [4, 6, 9, 9, 7, 6]]),\n",
              " array([[4, 1, 5, 5, 9, 1],\n",
              "        [5, 2, 5, 3, 1, 3]]),\n",
              " array([[8, 7, 7, 8, 2, 9],\n",
              "        [8, 8, 6, 5, 8, 9]])]"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.vsplit(d, 3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XBwuZmgqdQeM"
      },
      "source": [
        "hsplit(): This function splits an array horizontally into multiple subarrays by specifying the number of equally-sized parts or the indices at which to split the array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8iONnifacYqJ",
        "outputId": "842f963d-88f4-49f1-99a4-2d93f2230de4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[array([[5, 2, 4],\n",
              "        [4, 6, 9],\n",
              "        [4, 1, 5],\n",
              "        [5, 2, 5],\n",
              "        [8, 7, 7],\n",
              "        [8, 8, 6]]),\n",
              " array([[9, 8, 6],\n",
              "        [9, 7, 6],\n",
              "        [5, 9, 1],\n",
              "        [3, 1, 3],\n",
              "        [8, 2, 9],\n",
              "        [5, 8, 9]])]"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.hsplit(d, 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zFTkfzI5eCVW"
      },
      "source": [
        "shape: The shape function returns a tuple of integers that represents the dimensions of the array. Each integer in the tuple corresponds to the size of the array along that particular dimension.\n",
        "\n",
        "size: The size function returns the total number of elements in the array. It returns an integer representing the size of the array.\n",
        "\n",
        "ndim: The ndim function returns the number of dimensions of the array. It returns an integer representing the number of axes or dimensions in the array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SGoq0c5Kw681",
        "outputId": "c9324eb0-ca3f-45cd-f119-b5d5c8825d48"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[5, 2, 4, 9, 8, 6],\n",
              "       [4, 6, 9, 9, 7, 6],\n",
              "       [4, 1, 5, 5, 9, 1],\n",
              "       [5, 2, 5, 3, 1, 3],\n",
              "       [8, 7, 7, 8, 2, 9],\n",
              "       [8, 8, 6, 5, 8, 9]])"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pIZBGElqceMK",
        "outputId": "f3826866-f851-4b53-a349-a3a3b3daa3e8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(6, 6)"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jm6OhE4_daXW",
        "outputId": "2fb492d1-1700-47e2-9baa-72e9c8d6192f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "36"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d.size"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "78HGLQqAdflC",
        "outputId": "9a893ee0-155a-437e-d80b-d16ef9caf20b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d.ndim"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c-Z4o6mWeoYR"
      },
      "source": [
        "Reshaping: The reshape() function is used to change the shape of an array without altering its data. Reshaping allows you to rearrange the elements of an array into a different shape, as long as the total number of elements remains the same."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bmO2hmJYdhcU",
        "outputId": "36effa87-437c-40c5-a422-37f4a6043c68"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[5, 2, 4, 9, 8, 6],\n",
              "       [4, 6, 9, 9, 7, 6],\n",
              "       [4, 1, 5, 5, 9, 1],\n",
              "       [5, 2, 5, 3, 1, 3],\n",
              "       [8, 7, 7, 8, 2, 9],\n",
              "       [8, 8, 6, 5, 8, 9]])"
            ]
          },
          "execution_count": 30,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BbKGJVyUer3Q",
        "outputId": "8fd8a750-e566-4373-d6d3-291e515dd192"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[5, 2, 4, 9],\n",
              "       [8, 6, 4, 6],\n",
              "       [9, 9, 7, 6],\n",
              "       [4, 1, 5, 5],\n",
              "       [9, 1, 5, 2],\n",
              "       [5, 3, 1, 3],\n",
              "       [8, 7, 7, 8],\n",
              "       [2, 9, 8, 8],\n",
              "       [6, 5, 8, 9]])"
            ]
          },
          "execution_count": 31,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d.reshape(9, 4)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ry60CGbrjq9k"
      },
      "source": [
        "**Dimension addition**\n",
        "\n",
        "Newaxis is a special indexing object that is used to increase the dimensions of an array by one. It is used to insert a new axis into an existing array at a specified position. The newaxis object is typically used during array manipulations or broadcasting operations to align the shapes of arrays."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "iBSI_1HHew4R"
      },
      "outputs": [],
      "source": [
        "s = np.array([1,2,3,4,5])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pvx8wxYRiwiY",
        "outputId": "c102472b-9ee4-4b5e-cba9-52e3d44cea86"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5])"
            ]
          },
          "execution_count": 33,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "s"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ykpjd4NPi3WF",
        "outputId": "99430ad0-4b18-461a-b3af-25a9d4b8b1d5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1],\n",
              "       [2],\n",
              "       [3],\n",
              "       [4],\n",
              "       [5]])"
            ]
          },
          "execution_count": 34,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = s[:, np.newaxis]\n",
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-gACpW8hjD_q",
        "outputId": "b9f52dc0-f96a-4ce6-bec2-0515e610e53e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(5, 1)"
            ]
          },
          "execution_count": 35,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "79uH6V88jGUS",
        "outputId": "d16bc85f-b806-492d-f15a-044b49c3a5d7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[[1]],\n",
              "\n",
              "       [[2]],\n",
              "\n",
              "       [[3]],\n",
              "\n",
              "       [[4]],\n",
              "\n",
              "       [[5]]])"
            ]
          },
          "execution_count": 36,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y = s[:, np.newaxis, np.newaxis]\n",
        "y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g6vk1IwqjN2k",
        "outputId": "66a35d7d-f612-4ad6-c773-6b8ba8fa87bd"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(5, 1, 1)"
            ]
          },
          "execution_count": 37,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zb0DFQSsmUSq"
      },
      "source": [
        "**Mathematical Funactions**\n",
        "\n",
        "NumPy has huge list of mathematical functions to make implementation of Machine Learning algorithms easily.\n",
        "\n",
        "Few of them are:\n",
        "\n",
        "\n",
        "\n",
        "*   Max                             \n",
        "*   Min\n",
        "*   Mean\n",
        "*   Std\n",
        "*   Cov\n",
        "*   Cumprod\n",
        "*   All\n",
        "*   Any\n",
        "*   Sum\n",
        "*   Dot\n",
        "*   Multiply\n",
        "*   Sqrt\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p-SBykqMjPTW",
        "outputId": "960d9295-e7f1-49b2-830b-df0ade01759d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[5, 2, 4, 9, 8, 6],\n",
              "       [4, 6, 9, 9, 7, 6],\n",
              "       [4, 1, 5, 5, 9, 1],\n",
              "       [5, 2, 5, 3, 1, 3],\n",
              "       [8, 7, 7, 8, 2, 9],\n",
              "       [8, 8, 6, 5, 8, 9]])"
            ]
          },
          "execution_count": 38,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "d"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0-QG-kzfsobm",
        "outputId": "bef9e2ce-b00f-4a91-8e57-d5781bcc4ef2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([34, 41, 25, 19, 41, 44])"
            ]
          },
          "execution_count": 39,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.sum(d, axis = 1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ziVdLQBCs3c-",
        "outputId": "23330329-bd01-4433-8c45-2d81e8fa74dc"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2.0"
            ]
          },
          "execution_count": 40,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.sqrt(4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bK1vRmwXtlgt",
        "outputId": "dc21555f-b41e-45da-bc5d-f93b5a1370ef"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "execution_count": 41,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.max(d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pPW7INBitqrp",
        "outputId": "4f6c6e30-12a4-4392-890e-05cf7bf6f4a6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 42,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "np.min(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c-CQOBRRvlJF"
      },
      "source": [
        "**Broadcasting**\n",
        "\n",
        "Broadcasting is a powerful feature in NumPy that allows for implicit element-wise operations between arrays of different shapes and sizes. It eliminates the need for explicit loops or manual alignment of array shapes, making code more concise and efficient.\n",
        "\n",
        "In NumPy, broadcasting works by automatically extending or \"broadcasting\" smaller arrays to match the shape of larger arrays. The broadcasting rules determine how arrays with different shapes are aligned and how the element-wise operations are performed."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KINWlfBktsvK",
        "outputId": "c50a2f5c-932e-4580-cbae-b7a581182800"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([5, 3, 2])"
            ]
          },
          "execution_count": 43,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "a = np.array([5, 3, 2])\n",
        "a"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mmAiU3kNv6c8",
        "outputId": "de087eab-64e2-4882-c0f3-5622d6f6250e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([4, 7, 8])"
            ]
          },
          "execution_count": 44,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "b = np.array([4, 7, 8])\n",
        "b"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pjul1mw5v_i1",
        "outputId": "866c5a80-453d-43f6-87fe-bb1930abbd5d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 9, 10, 10])"
            ]
          },
          "execution_count": 45,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#Broadcasting\n",
        "\n",
        "c = a + b\n",
        "c"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D-mXofnqbldj"
      },
      "source": [
        "Different size and shape can cause error in broadcasting"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "id": "4AdQwO0Xevfq"
      },
      "outputs": [],
      "source": [
        "i = np.array([[2,3,4], [5,7,8]])\n",
        "j = np.array([[2,3,4], [9,7,8], [2,7,4]])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "id": "1b5_AvmKwPiI",
        "outputId": "94506e03-eb9c-45c1-d3dd-4027a7389b7e"
      },
      "outputs": [
        {
          "ename": "ValueError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-52-71927a4d0bf1>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mk\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,3) (3,3) "
          ]
        }
      ],
      "source": [
        "k = i + j"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H3MKx99FcbOt"
      },
      "source": [
        "Therefore dimension should be increased of array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wOlaPA58baMG",
        "outputId": "45984bba-0a93-4dc6-dd1a-38dbd08704d3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(2, 3)"
            ]
          },
          "execution_count": 53,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "i.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PNnIj2K7eq_V",
        "outputId": "53fa3520-3043-460b-b601-a1bc82aa9023"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(3, 3)"
            ]
          },
          "execution_count": 54,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "j.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-_uB-qrofod_",
        "outputId": "1bdc1ba2-f343-49c5-b70a-dd8ffaf9aa6e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[[ 4,  6,  8],\n",
              "        [ 7, 10, 12]],\n",
              "\n",
              "       [[11, 10, 12],\n",
              "        [14, 14, 16]],\n",
              "\n",
              "       [[ 4, 10,  8],\n",
              "        [ 7, 14, 12]]])"
            ]
          },
          "execution_count": 55,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "k = i.reshape(1,2,3) + j.reshape(3,1,3)\n",
        "k"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.9.13"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}