Numpy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyO6LnPrw31TWF82DePuLNji",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ambilisunil/python_basics/blob/main/Numpy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# NumPy for Machine Learning & Data Science\n",
        "NumPy (Numerical Python) is a core library for numerical computing in Python. It's heavily used in Machine Learning, Data Science, and Deep Learning because it provides fast, efficient operations on large datasets."
      ],
      "metadata": {
        "id": "-FQB9gpf7I5K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np"
      ],
      "metadata": {
        "id": "hGxXWbVe76W1"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Creating an array\n",
        "arr = np.array([1, 2.5, 3, 4, 5])\n",
        "print(arr)  # Output: [1 2 3 4 5]\n",
        "\n",
        "# Shape & size\n",
        "print(arr.shape)   # (5,) → 1D array with 5 elements\n",
        "print(arr.size)    # 5 → Total elements\n",
        "print(arr.dtype)   # int64 → Data type\n",
        "print(type(arr))\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b9SCm2QR7T80",
        "outputId": "cf265ebd-cfaa-4520-953b-071f4b81f1b9"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1.  2.5 3.  4.  5. ]\n",
            "(5,)\n",
            "5\n",
            "float64\n",
            "<class 'numpy.ndarray'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "arr[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aAd5FAJE86ul",
        "outputId": "ea92ee2a-b73d-42e3-a571-5f1a9dc8887e"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(arr[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QkduRwEm8_qF",
        "outputId": "a2d96322-0433-4bd5-c342-68ab665b8ab8"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "numpy.int64"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(arr[1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cPUabqI19HgL",
        "outputId": "65d08847-9064-45a1-9165-6a5b215222b0"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "numpy.float64"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# MULTIPLE *DIMESIONAL*"
      ],
      "metadata": {
        "id": "Pn2eFjem9Quh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "md=np.array([[1,2],[2,3]])\n",
        "print(md)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ifofWI3C9WjT",
        "outputId": "c04a0cc6-4e1c-47b1-c737-04d5cf424e79"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2]\n",
            " [2 3]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# NONES AND ZEROS\n",
        "\n",
        "\n",
        ">np.ones((m,n)) m*n matrix filled with 1\n",
        "\n",
        "\n",
        "> np.zeros((m,n)) m*n matrix filled with 0\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "T1B1XIfz-Wfz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nones= np.ones((2,2))\n",
        "print(nones)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GdJHjWfh--PT",
        "outputId": "8141ff5f-7743-41a6-fb63-7af262714d10"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1. 1.]\n",
            " [1. 1.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nones= np.ones((2))\n",
        "print(nones)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5sjAmyR0-Zpc",
        "outputId": "384aef8f-ee9f-4d9f-c1d0-7a1dfb8f4c53"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1. 1.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "zeros= np.zeros((4,4))\n",
        "print(zeros)\n",
        "print(zeros.shape)\n",
        "print(type(zeros))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CO8RPk70_WOh",
        "outputId": "d15f43b9-0e65-4af4-c200-3aaa6f866354"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0. 0. 0. 0.]\n",
            " [0. 0. 0. 0.]\n",
            " [0. 0. 0. 0.]\n",
            " [0. 0. 0. 0.]]\n",
            "(4, 4)\n",
            "<class 'numpy.ndarray'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# RANDOM NUMBER NUMPY"
      ],
      "metadata": {
        "id": "fEDdZxGqAKAd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.random((2,2))   #print 2*2 shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3XkPTs_MAPfM",
        "outputId": "82019916-2ae4-4379-fda0-5d7551b199fb"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.06594282, 0.05614594],\n",
              "       [0.04073486, 0.48229081]])"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "MATH OPERTIONS"
      ],
      "metadata": {
        "id": "SBh7rAI6B6LL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a=10\n",
        "b=20"
      ],
      "metadata": {
        "id": "nhwDui-zB90-"
      },
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.add(a,b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s16Ez_ZzCBas",
        "outputId": "1e671ace-18af-4e0e-d134-3e25db9457f9"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "30"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.subtract(10,20)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2mU9aEDYCEla",
        "outputId": "657c0b2b-5241-4113-d446-ed70994ebf88"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-10"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.multiply(a,b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u4eImzVgCXIj",
        "outputId": "91b4e433-fc10-4650-82ac-6c9c079ec171"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "200"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.divide(b,a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TmfZou9nCbmL",
        "outputId": "51b85c3c-68a3-4be7-9e49-8debe449da8a"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.0"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# CONCATINATE NUMPY"
      ],
      "metadata": {
        "id": "QQDGI17OC2pi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a1= np.array([1,2,3])\n",
        "a2= np.array([2,3.4])"
      ],
      "metadata": {
        "id": "9dqDPTzMC8zF"
      },
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.concatenate((a1,a2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lvRov-TiDH8y",
        "outputId": "9f362ab7-a3ca-4243-9b0c-9c8b208e9f08"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1. , 2. , 3. , 2. , 3.4])"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**CONCATINATE MULTIPLE DIMENSIONAL**"
      ],
      "metadata": {
        "id": "4AqqD7dTIE0o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n1=np.array([[1,2,3],[4,5,6]])\n",
        "n2=np.array([[7,8,9],[10,11,12]])\n",
        "print(n1)\n",
        "print(\"\")\n",
        "\n",
        "print(n2)\n",
        "print(\"\")\n",
        "print(n1.shape)\n",
        "print(n2.shape)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ek9UqDwOIMwT",
        "outputId": "bbcd633c-42ce-423c-c70c-df379077dfa3"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]]\n",
            "\n",
            "[[ 7  8  9]\n",
            " [10 11 12]]\n",
            "\n",
            "(2, 3)\n",
            "(2, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vertical Concatenation **(axis=0)**\n",
        "**Joins arrays top to bottom (row-wise)**\n",
        "Works for 2D arrays (matrices)\n",
        "\n",
        "\n",
        ">Horizontal Concatenation **(axis=1)**\n",
        "Joins arrays side by side **(column-wise)**\n",
        "Works for 2D arrays (matrices)\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "g9Wlehd5KbQ6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n3= np.concatenate((n1,n2),axis=0)  # vertically conactinate\n",
        "print(n3)\n",
        "print(\"\")\n",
        "\n",
        "print(n3.shape)\n",
        "\n",
        "print(\"\")\n",
        "\n",
        "n4= np.concatenate((n1,n2),axis=1)  # horizontal conactinate\n",
        "print(n4,)\n",
        "print(\"\")\n",
        "\n",
        "print(n4.shape)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NTV833VoJgJy",
        "outputId": "fd3b1e84-5d10-4a5b-c22f-44fb788ab924"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]]\n",
            "\n",
            "(4, 3)\n",
            "\n",
            "[[ 1  2  3  7  8  9]\n",
            " [ 4  5  6 10 11 12]]\n",
            "\n",
            "(2, 6)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**hstack** **vstack**- other way of  vertical and horizonatal concatination"
      ],
      "metadata": {
        "id": "GrsEzNo_LV28"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hstack=np.hstack((n1,n2))\n",
        "print(hstack)\n",
        "print(\"\")\n",
        "print(hstack.shape)\n",
        "print(\"\")\n",
        "\n",
        "vstack=np.vstack((n1,n2))\n",
        "print(vstack)\n",
        "print(\"\")\n",
        "print(vstack.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "liM90cAnLhxQ",
        "outputId": "880aad72-68e7-4bfd-a2b6-f97ae62b5110"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2  3  7  8  9]\n",
            " [ 4  5  6 10 11 12]]\n",
            "\n",
            "(2, 6)\n",
            "\n",
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]]\n",
            "\n",
            "(4, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# RESHAPE ARRAY\n",
        "\n",
        "\n",
        ">NumPy **reshape**(): Changing the Shape of an Array\n",
        "\n",
        "\n",
        "> The reshape() function in NumPy changes the shape of an array without changing its data.\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "xpGmDhO0OFmT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rs=np.array(([[1,2,32,77],[2,3,0,7]]))\n",
        "rs.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vtPDiepyOYQY",
        "outputId": "fba66981-af99-4613-c10f-40368d1ac9ef"
      },
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 4)"
            ]
          },
          "metadata": {},
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(rs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DmY0TLmVOo5-",
        "outputId": "60923806-6efe-4cce-fed4-47845d0f4a42"
      },
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2 32 77]\n",
            " [ 2  3  0  7]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rs_c=rs.reshape(8)\n",
        "print(rs_c)\n",
        "print(rs_c.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hgo8muGnOrIt",
        "outputId": "3e7706e3-0770-4fc9-b5f5-2e1a2b8cc905"
      },
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 1  2 32 77  2  3  0  7]\n",
            "(8,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rs_c=np.reshape(rs,(4,2))\n",
        "print(rs_c)\n",
        "print(rs_c.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wm4uDZl4PNQa",
        "outputId": "55fccd3f-86e2-403c-b33e-2704a898c1ec"
      },
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2]\n",
            " [32 77]\n",
            " [ 2  3]\n",
            " [ 0  7]]\n",
            "(4, 2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **flatten()** and  **ravel()** in NumPy 🚀\n",
        "\n",
        "\n",
        "> Both flatten() and ravel() convert a multi-dimensional array into a 1D array, but they have key differences in memory behavior.\n",
        "\n",
        "\n",
        "> flatten(): Returns a Copy\n",
        "Creates a new copy of the data\n",
        "Changes to the new array do NOT affect the original array\n",
        "Always allocates new memory\n",
        "\n",
        "\n",
        "\n",
        "> A Returns a View (If Possible)\n",
        "Does NOT create a new copy if possible (returns a view instead)\n",
        "Changes to the ravel() array MAY affect the original array\n",
        "More memory-efficient\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "**bold text**"
      ],
      "metadata": {
        "id": "YpfStezURJbp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rs=np.array(([[1,2,32,77],[2,3,0,7]]))\n",
        "\n",
        "flattern =rs.flatten()\n",
        "ravel= np.ravel(rs)\n",
        "\n",
        "print(rs)\n",
        "print(flattern)\n",
        "\n",
        "print(ravel)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nvbgY2KXRRe5",
        "outputId": "a514febc-b179-4eb7-8562-178457c0b7d3"
      },
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2 32 77]\n",
            " [ 2  3  0  7]]\n",
            "[ 1  2 32 77  2  3  0  7]\n",
            "[ 1  2 32 77  2  3  0  7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(rs)\n",
        "print(\"\")\n",
        "print(np.ravel(rs,order=\"F\")) #colum major\n",
        "print(np.ravel(rs,order=\"C\")) #raw major"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e5Y7G_IzSpoL",
        "outputId": "81df175c-384e-40ec-a285-c8dae0c628a6"
      },
      "execution_count": 118,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2 32 77]\n",
            " [ 2  3  0  7]]\n",
            "\n",
            "[ 1  2  2  3 32  0 77  7]\n",
            "[ 1  2 32 77  2  3  0  7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **EXPAND**"
      ],
      "metadata": {
        "id": "JbXnDXuXUCaV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a=np.array([100,200,300])\n",
        "print(a)\n",
        "print(a.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wbEu6petUFuO",
        "outputId": "6f3a1a96-f973-4302-a5c2-9b3ba7b03603"
      },
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[100 200 300]\n",
            "(3,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a1=np.expand_dims(a,axis=0)\n",
        "print(a1)\n",
        "print(a1.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q2RlVlTNUQ0C",
        "outputId": "8a7f6811-b7c5-4e8b-a2c2-554885ffea66"
      },
      "execution_count": 121,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[100 200 300]]\n",
            "(1, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a2=np.expand_dims(a,axis=1)\n",
        "print(a2)\n",
        "print(a2.shape)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bmDNkufFUh31",
        "outputId": "c23796ba-b5d4-413c-a898-65330211a89a"
      },
      "execution_count": 122,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[100]\n",
            " [200]\n",
            " [300]]\n",
            "(3, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# TRANSPONSE:\n",
        "\n",
        "\n",
        "> NumPy transpose() and** .**T: Swapping Axes of an Array 🚀\n",
        "transpose() is used to swap the dimensions (axes) of a NumPy array, often for matrix operations, deep learning, and broadcasting.\n",
        "\n",
        "\n",
        "> raws are colums and columns arev raws\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "X9cULm8mU--Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "arr = np.array([[1, 2, 3],\n",
        "                [4, 5, 6]])\n",
        "\n",
        "transposed = np.transpose(arr) #mthd   1\n",
        "\n",
        "\n",
        "\n",
        "print(transposed)\n",
        "print(\"  \")\n",
        "print(arr.T)  #mthd 2\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7F2EqVMsVRqx",
        "outputId": "ec02fecc-d96f-4e11-b8cb-8a8cdb1de63e"
      },
      "execution_count": 126,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 4]\n",
            " [2 5]\n",
            " [3 6]]\n",
            "  \n",
            "[[1 4]\n",
            " [2 5]\n",
            " [3 6]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# UNIQUE"
      ],
      "metadata": {
        "id": "Dtpj0G0WVzaE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**NumPy unique()**: Finding Unique Elements in an Array\n",
        "\n",
        "np.unique() is used to find unique elements in a NumPy array.\n",
        "\n",
        "It can also return additional information, like counts and indices.\n",
        "\n"
      ],
      "metadata": {
        "id": "4srYsgnmWAJG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arr = np.array([1, 2, 2, 3, 4, 4, 4, 5])\n",
        "unique_values = np.unique(arr)\n",
        "\n",
        "print(unique_values)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bUq5XQLLV2TS",
        "outputId": "24754f57-c4de-4a95-fbc8-e23034ccef12"
      },
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "return_counts: Count of Each Unique Element\n"
      ],
      "metadata": {
        "id": "y1glHFx5WN_y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "unique_values, counts = np.unique(arr, return_counts=True)\n",
        "print(unique_values)  # [1 2 3 4 5]\n",
        "print(counts)         # [1 2 1 3 1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dYFCYnKiWLVb",
        "outputId": "94c39e27-8388-423a-e464-1a2c8e0ef49e"
      },
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4 5]\n",
            "[1 2 1 3 1]\n"
          ]
        }
      ]
    }
  ]
}