Session5_NumPy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNCfEEBQ6ow8wBzqOoc6uym",
      "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/farhadrahimiinfo/Python-Learning/blob/main/Session5_NumPy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#refrence: https://www.w3schools.com/"
      ],
      "metadata": {
        "id": "gFq2NoLzF3gk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# NumPy Introduction\n",
        "What is NumPy?\n",
        "NumPy is a Python library used for working with arrays.\n",
        "\n",
        "It also has functions for working in domain of linear algebra, fourier transform, and matrices.\n",
        "\n",
        "NumPy was created in 2005 by Travis Oliphant. It is an open source project and you can use it freely.\n",
        "\n",
        "NumPy stands for Numerical Python."
      ],
      "metadata": {
        "id": "LamTywWRBgtU"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M8lIsg8eBct3",
        "outputId": "dcb5be26-6481-46e5-c6d6-6d438b33b8d1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4 5]\n"
          ]
        }
      ],
      "source": [
        "import numpy\n",
        "\n",
        "arr = numpy.array([1, 2, 3, 4, 5])\n",
        "\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "print(arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fFHQWKTnBscY",
        "outputId": "6deaab77-7ca0-48b4-c305-af765fe1db9e"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "print(np.__version__)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A9iEMhqMB9VA",
        "outputId": "dd993292-a9fe-40e1-d778-7f757d7a431d"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.25.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "print(arr)\n",
        "\n",
        "print(type(arr))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_yW3fCaFB-DT",
        "outputId": "3515490c-851d-4873-fd7d-fa3b8df81cc9"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4 5]\n",
            "<class 'numpy.ndarray'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array(42)\n",
        "\n",
        "print(arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AhBJ2_LuCJCu",
        "outputId": "7fdbd499-32ac-4234-ccb2-27542ac43e7c"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "42\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "\n",
        "print(arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oVIJQ9YLCOIx",
        "outputId": "277ea447-c34e-4a81-dfea-b7ede792eac4"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
        "\n",
        "print(arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "osg2T853CRa1",
        "outputId": "9ae92cca-44b1-4063-de91-6145d94659c7"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[1 2 3]\n",
            "  [4 5 6]]\n",
            "\n",
            " [[1 2 3]\n",
            "  [4 5 6]]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Check Number of Dimensions?\n",
        "#NumPy Arrays provides the ndim attribute that returns an integer that tells us how many dimensions the array have.\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "a = np.array(42)\n",
        "b = np.array([1, 2, 3, 4, 5])\n",
        "c = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
        "\n",
        "print(a.ndim)\n",
        "print(b.ndim)\n",
        "print(c.ndim)\n",
        "print(d.ndim)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Mh6A5kQCZXQ",
        "outputId": "c58a2298-6986-47ba-af7d-647c3141e55d"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4], ndmin=5)\n",
        "\n",
        "print(arr)\n",
        "print('number of dimensions :', arr.ndim)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7GDL1kVaCmxw",
        "outputId": "b34e5d30-c4cf-4295-93ce-b4cbb6d03f0c"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[[[1 2 3 4]]]]]\n",
            "number of dimensions : 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4])\n",
        "\n",
        "print(arr[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "70_k6RTCCsr5",
        "outputId": "a67b16c6-0b4c-44d0-bb68-efbbe97356f8"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4])\n",
        "\n",
        "print(arr[2] + arr[3])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OgM_CPwTCvNG",
        "outputId": "20f8f6fa-7f0b-438a-ce35-73ddc4e65e76"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])\n",
        "\n",
        "print('2nd element on 2st row: ', arr[1, 1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "riRGS_O7CzRi",
        "outputId": "9a69938e-ac3c-4636-86d1-3d821ee324d8"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2nd element on 2st row:  7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
        "\n",
        "print(arr[0, 1, 2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kbxxlka5C85A",
        "outputId": "397a46fa-74e0-490f-e123-a79cd1e95e64"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# NumPy Array Slicing\n",
        "Slicing arrays\n",
        "Slicing in python means taking elements from one given index to another given index.\n",
        "\n",
        "We pass slice instead of index like this: [start:end].\n",
        "\n",
        "We can also define the step, like this: [start:end:step].\n",
        "\n",
        "If we don't pass start its considered 0\n",
        "\n",
        "If we don't pass end its considered length of array in that dimension\n",
        "\n",
        "If we don't pass step its considered 1"
      ],
      "metadata": {
        "id": "rN6pFgiYDd80"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
        "\n",
        "print(arr[1:5])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MlgXhgEwDidl",
        "outputId": "33776c37-d2eb-4176-f613-e5daefff7585"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2 3 4 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
        "\n",
        "print(arr[4:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GbtVPYqrDu-a",
        "outputId": "321af069-380b-4a8b-99ee-c3aeb63fe688"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[5 6 7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
        "\n",
        "print(arr[:4])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CoqtVZs4D1Fe",
        "outputId": "0604e0cd-4b78-44ca-87c0-737f6f934a3e"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
        "\n",
        "print(arr[-3:-1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g1lGXet4D4aZ",
        "outputId": "1289341a-15d4-43ca-97c5-1ec4734c7f4f"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[5 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# STEP\n",
        "\n",
        "Use the step value to determine the step of the slicing:\n",
        "\n"
      ],
      "metadata": {
        "id": "EB5nl5pfEXGr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
        "\n",
        "print(arr[1:5:2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BaN0WdlOELl5",
        "outputId": "e2260537-c017-435b-aaae-740055ebb79d"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
        "\n",
        "print(arr[::2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gShvKjptEQH5",
        "outputId": "d7540840-0bc6-48c2-f1e4-303df6d7b7b3"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 3 5 7]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "8yPIL85REZu2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Slicing 2-D Arrays\n"
      ],
      "metadata": {
        "id": "vGrdjR0UEd_3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#From the second element, slice elements from index 1 to index 4 (not included):\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])\n",
        "\n",
        "print(arr[1, 1:4])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SPaY0_dtEhMH",
        "outputId": "692abee9-821a-4d48-8ab4-d90265d38bd0"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[7 8 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])\n",
        "\n",
        "print(arr[0:2, 2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cRBUte6IEudl",
        "outputId": "03965459-be04-4443-cb55-eb90d274ad8c"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])\n",
        "\n",
        "print(arr[0:2, 1:4])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DDscRbTtEyV5",
        "outputId": "f342bb66-b1e0-465b-fec0-6d5fd6e0eb39"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[2 3 4]\n",
            " [7 8 9]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "sxpb8YT4E6HB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# NumPy Data Types\n",
        "Data Types in Python\n",
        "By default Python have these data types:\n",
        "\n",
        "strings - used to represent text data, the text is given under quote marks. e.g. \"ABCD\"\n",
        "\n",
        "integer - used to represent integer numbers. e.g. -1, -2, -3\n",
        "\n",
        "float - used to represent real numbers. e.g. 1.2, 42.42\n",
        "\n",
        "boolean - used to represent True or False.\n",
        "\n",
        "complex - used to represent complex numbers. e.g. 1.0 + 2.0j, 1.5 + 2.5j\n",
        "\n",
        "NumPy has some extra data types, and refer to data types with one character, like i for integers, u for unsigned integers etc.\n",
        "\n",
        "\n",
        "**Below is a list of all data types in NumPy and the characters used to represent them.**\n",
        "\n",
        "i - integer\n",
        "\n",
        "b - boolean\n",
        "\n",
        "u - unsigned integer\n",
        "\n",
        "f - float\n",
        "\n",
        "c - complex float\n",
        "\n",
        "m - timedelta\n",
        "\n",
        "M - datetime\n",
        "\n",
        "O - object\n",
        "\n",
        "S - string\n",
        "\n",
        "U - unicode string\n",
        "\n",
        "V - fixed chunk of memory for other type ( void )\n"
      ],
      "metadata": {
        "id": "YnFokuHSE7PD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4])\n",
        "\n",
        "print(arr.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_NiVimNtE-08",
        "outputId": "378b2a8b-4cd2-4c2b-ff7c-ab058e3b9112"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "int64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array(['apple', 'banana', 'cherry'])\n",
        "\n",
        "print(arr.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mz9fWZWYFMvC",
        "outputId": "b720f084-f450-4b17-b271-053e8c6f600b"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<U6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4], dtype='S')\n",
        "\n",
        "print(arr)\n",
        "print(arr.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JjwvIJSdFP0n",
        "outputId": "a78812a7-bcd4-45e5-eec1-981ede41609e"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[b'1' b'2' b'3' b'4']\n",
            "|S1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4], dtype='i4')\n",
        "\n",
        "print(arr)\n",
        "print(arr.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AhVLrZqnFoGW",
        "outputId": "9bc52795-3427-49a2-b943-bf5162ad6880"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4]\n",
            "int32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Convert\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([1.1, 2.1, 3.1])\n",
        "\n",
        "newarr = arr.astype('i')\n",
        "\n",
        "print(newarr)\n",
        "print(newarr.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GkkvVpzpFtNe",
        "outputId": "eb91702d-8427-49be-cd33-dfe68943b3ad"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3]\n",
            "int32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1.1, 2.1, 3.1])\n",
        "\n",
        "newarr = arr.astype(int)\n",
        "\n",
        "print(newarr)\n",
        "print(newarr.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HN15VqXrFzGA",
        "outputId": "1174eb2b-9a04-4d88-8aed-322e1b5bbb75"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3]\n",
            "int64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 0, 3])\n",
        "\n",
        "newarr = arr.astype(bool)\n",
        "\n",
        "print(newarr)\n",
        "print(newarr.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fDXbppMOF-8g",
        "outputId": "9c80abbf-0fb6-425b-c836-a85752839177"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ True False  True]\n",
            "bool\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Copy\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5])\n",
        "x = arr.copy()\n",
        "arr[0] = 42\n",
        "\n",
        "print(arr)\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W0MSnEESGHrq",
        "outputId": "473194ca-d0eb-48cd-92ae-3be684745e37"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[42  2  3  4  5]\n",
            "[1 2 3 4 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#view\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5])\n",
        "x = arr.view()\n",
        "arr[0] = 42\n",
        "\n",
        "print(arr)\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EjuDpZmVGPwu",
        "outputId": "735b14a5-2b1f-4df2-b943-53b366d16981"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[42  2  3  4  5]\n",
            "[42  2  3  4  5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Make a view, change the view, and display both arrays:\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5])\n",
        "x = arr.view()\n",
        "x[0] = 31\n",
        "\n",
        "print(arr)\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3fTskfctGURi",
        "outputId": "dab01ba3-867b-462a-cebd-ea2e6bc24f2e"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[31  2  3  4  5]\n",
            "[31  2  3  4  5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Check if Array Owns its Data\n",
        "As mentioned above, copies owns the data, and views does not own the data, but how can we check this?\n",
        "\n",
        "Every NumPy array has the attribute base that returns None if the array owns the data.\n",
        "\n",
        "Otherwise, the base  attribute refers to the original object."
      ],
      "metadata": {
        "id": "vPYIkv0KGgbX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "x = arr.copy()\n",
        "y = arr.view()\n",
        "\n",
        "print(x.base)\n",
        "print(y.base)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xpAfjxqyGn9w",
        "outputId": "fdedfd9e-4d3a-494a-db6f-16b2de239cda"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None\n",
            "[1 2 3 4 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# NumPy Array Shape\n",
        "The shape of an array is the number of elements in each dimension.\n",
        "\n"
      ],
      "metadata": {
        "id": "ro3vs2w9Gx4C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "\n",
        "print(arr.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JW0202r4G0xp",
        "outputId": "faa3f145-8193-4fff-c15a-0804d61dfee1"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4], ndmin=5)\n",
        "\n",
        "print(arr)\n",
        "print('shape of array :', arr.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m-luc72qG6CE",
        "outputId": "1b24eded-92d0-4cb0-f8a0-e7f5ca653911"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[[[1 2 3 4]]]]]\n",
            "shape of array : (1, 1, 1, 1, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#reshape\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\n",
        "\n",
        "newarr = arr.reshape(4, 3)\n",
        "\n",
        "print(newarr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4PNFEoycHF75",
        "outputId": "2ba3fdd0-a81b-4ee0-879f-00db0b3c7b82"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\n",
        "\n",
        "newarr = arr.reshape(2, 3, 2)\n",
        "\n",
        "print(newarr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9lbxcbueHKSn",
        "outputId": "21817275-a108-4f69-f482-943e8af6373f"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[ 1  2]\n",
            "  [ 3  4]\n",
            "  [ 5  6]]\n",
            "\n",
            " [[ 7  8]\n",
            "  [ 9 10]\n",
            "  [11 12]]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
        "\n",
        "print(arr.reshape(2, 4).base)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tklxqaX2HP-p",
        "outputId": "229dbc92-0b62-4e04-e245-1eb7b6dacb8a"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4 5 6 7 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Iterating Arrays\n",
        "Iterating means going through elements one by one.\n",
        "\n",
        "As we deal with multi-dimensional arrays in numpy, we can do this using basic for loop of python.\n",
        "\n",
        "If we iterate on a 1-D array it will go through each element one by one.\n",
        "\n"
      ],
      "metadata": {
        "id": "OBInUGnoHXbq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3])\n",
        "\n",
        "for x in arr:\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ig-r93FSHjMm",
        "outputId": "ba288a33-4338-4299-86a2-9d30477c3934"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "\n",
        "for x in arr:\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M5bwN4iqHmkC",
        "outputId": "9597ac50-1a8d-4725-e078-05e9a6eed6b6"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3]\n",
            "[4 5 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "\n",
        "for x in arr:\n",
        "  for y in x:\n",
        "    print(y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RW4cHBigHrWA",
        "outputId": "07348d5d-c83b-4c5c-de1a-9d3d783383f4"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
        "\n",
        "for x in arr:\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NB6UbXhKHvLN",
        "outputId": "39fcebcc-bb47-45db-e5ab-10febafaf3c3"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]]\n",
            "[[ 7  8  9]\n",
            " [10 11 12]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\n",
        "\n",
        "for x in arr:\n",
        "  for y in x:\n",
        "    for z in y:\n",
        "      print(z)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5cuxHG3jH0Gz",
        "outputId": "b6a896ee-38fc-4348-b27e-c55e52179f2d"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "11\n",
            "12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Iterating Arrays Using nditer()\n",
        "The function nditer() is a helping function that can be used from very basic to very advanced iterations. It solves some basic issues which we face in iteration, lets go through it with examples.\n",
        "\n",
        "Iterating on Each Scalar Element\n",
        "In basic for loops, iterating through each scalar of an array we need to use n for loops which can be difficult to write for arrays with very high dimensionality.\n",
        "\n"
      ],
      "metadata": {
        "id": "dCZzAbXrH3i1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])\n",
        "\n",
        "for x in np.nditer(arr):\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JKBjP3ZTH8tE",
        "outputId": "6d03340e-dda8-4741-a662-f04b0d713e16"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Iterating Array With Different Data Types\n",
        "We can use op_dtypes argument and pass it the expected datatype to change the datatype of elements while iterating.\n",
        "\n",
        "NumPy does not change the data type of the element in-place (where the element is in array) so it needs some other space to perform this action, that extra space is called buffer, and in order to enable it in nditer() we pass flags=['buffered'].\n",
        "\n"
      ],
      "metadata": {
        "id": "fmSwWBRIIN6k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3])\n",
        "\n",
        "for x in np.nditer(arr, flags=['buffered'], op_dtypes=['S']):\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nXN0VU0_IFpW",
        "outputId": "d55433a8-31bc-437b-febb-43d0bb5467d6"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b'1'\n",
            "b'2'\n",
            "b'3'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Iterate through every scalar element of the 2D array skipping 1 element:\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "\n",
        "for x in np.nditer(arr[:, ::2]):\n",
        "  print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zBP5s-EMIVHy",
        "outputId": "6499ff40-2de6-4b6d-cf1a-26c873608243"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "3\n",
            "5\n",
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Enumerated Iteration Using ndenumerate()\n",
        "#Enumeration means mentioning sequence number of somethings one by one.\n",
        "\n",
        "#Sometimes we require corresponding index of the element while iterating, the ndenumerate() method can be used for those usecases.\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3])\n",
        "\n",
        "for idx, x in np.ndenumerate(arr):\n",
        "  print(idx, x)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1jBM6dvsIcau",
        "outputId": "19861228-5400-4e6e-bc63-adcbffdcea6e"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0,) 1\n",
            "(1,) 2\n",
            "(2,) 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "\n",
        "for idx, x in np.ndenumerate(arr):\n",
        "  print(idx, x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ud8L4VMEIk8m",
        "outputId": "a694b653-f8c0-4467-f8b7-0ae8b2bdf426"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0, 0) 1\n",
            "(0, 1) 2\n",
            "(0, 2) 3\n",
            "(0, 3) 4\n",
            "(1, 0) 5\n",
            "(1, 1) 6\n",
            "(1, 2) 7\n",
            "(1, 3) 8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Joining NumPy Arrays\n"
      ],
      "metadata": {
        "id": "9ds1v-AWI1Bn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr1 = np.array([1, 2, 3])\n",
        "\n",
        "arr2 = np.array([4, 5, 6])\n",
        "\n",
        "arr = np.concatenate((arr1, arr2))\n",
        "\n",
        "print(arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fmvt9GtTIs7O",
        "outputId": "24b84f0e-aa07-4783-eb82-d2656274cb71"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4 5 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Join two 2-D arrays along rows (axis=1):\n",
        "\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "arr1 = np.array([[1, 2], [3, 4]])\n",
        "\n",
        "arr2 = np.array([[5, 6], [7, 8]])\n",
        "\n",
        "arr = np.concatenate((arr1, arr2), axis=1)\n",
        "\n",
        "print(arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h_mvLGlVI3-_",
        "outputId": "ac6cbdc7-8583-4287-ae3e-974052c8b226"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 5 6]\n",
            " [3 4 7 8]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Joining Arrays Using Stack Functions\n",
        "Stacking is same as concatenation, the only difference is that stacking is done along a new axis.\n",
        "\n",
        "We can concatenate two 1-D arrays along the second axis which would result in putting them one over the other, ie. stacking.\n",
        "\n",
        "We pass a sequence of arrays that we want to join to the stack() method along with the axis. If axis is not explicitly passed it is taken as 0.\n",
        "\n"
      ],
      "metadata": {
        "id": "jhGodZhYJLLU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr1 = np.array([1, 2, 3])\n",
        "\n",
        "arr2 = np.array([4, 5, 6])\n",
        "\n",
        "arr = np.stack((arr1, arr2), axis=1)\n",
        "\n",
        "print(arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Nafekq5JDL1",
        "outputId": "56b9ab9f-974e-4666-b8a6-9c462883d23f"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 4]\n",
            " [2 5]\n",
            " [3 6]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr1 = np.array([1, 2, 3])\n",
        "\n",
        "arr2 = np.array([4, 5, 6])\n",
        "\n",
        "arr = np.hstack((arr1, arr2))\n",
        "\n",
        "print(arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PAdT8EKyJcRW",
        "outputId": "f796bac2-f778-44a4-f9d4-9dffd46b1211"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4 5 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr1 = np.array([1, 2, 3])\n",
        "\n",
        "arr2 = np.array([4, 5, 6])\n",
        "\n",
        "arr = np.vstack((arr1, arr2))\n",
        "\n",
        "print(arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "86VP3Nn9Jhwq",
        "outputId": "0244d74e-14de-483a-933c-05b33855ab04"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr1 = np.array([1, 2, 3])\n",
        "\n",
        "arr2 = np.array([4, 5, 6])\n",
        "\n",
        "arr = np.dstack((arr1, arr2))\n",
        "\n",
        "print(arr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kSp7c3BfJlX9",
        "outputId": "b1aff4fd-9801-46a6-b4bc-eba853faa80e"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[1 4]\n",
            "  [2 5]\n",
            "  [3 6]]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Splitting NumPy Arrays\n",
        "Splitting is reverse operation of Joining.\n",
        "\n",
        "Joining merges multiple arrays into one and Splitting breaks one array into multiple.\n",
        "\n",
        "We use array_split() for splitting arrays, we pass it the array we want to split and the number of splits.\n",
        "\n"
      ],
      "metadata": {
        "id": "cORsOCtkJRaU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6])\n",
        "\n",
        "newarr = np.array_split(arr, 3)\n",
        "\n",
        "print(newarr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ljMnVZIyJs8E",
        "outputId": "ee49e3a9-7ed9-4f8a-b522-c56ade7022ae"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[array([1, 2]), array([3, 4]), array([5, 6])]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6])\n",
        "\n",
        "newarr = np.array_split(arr, 4)\n",
        "\n",
        "print(newarr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ruXcnOp1J1IJ",
        "outputId": "c1b723eb-b7e4-4051-fbdd-9c520c27504a"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[array([1, 2]), array([3, 4]), array([5]), array([6])]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6])\n",
        "\n",
        "newarr = np.array_split(arr, 3)\n",
        "\n",
        "print(newarr[0])\n",
        "print(newarr[1])\n",
        "print(newarr[2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tyBKjZcyJ7-q",
        "outputId": "5b33617f-d4c5-454e-a082-9972a0938992"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2]\n",
            "[3 4]\n",
            "[5 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]])\n",
        "\n",
        "newarr = np.array_split(arr, 3)\n",
        "\n",
        "print(newarr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HFMxleLiKABD",
        "outputId": "4846b974-cc37-427a-bb87-f7d06dc41b3b"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[array([[1, 2],\n",
            "       [3, 4]]), array([[5, 6],\n",
            "       [7, 8]]), array([[ 9, 10],\n",
            "       [11, 12]])]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Searching Arrays\n",
        "You can search an array for a certain value, and return the indexes that get a match.\n",
        "\n",
        "To search an array, use the where() method."
      ],
      "metadata": {
        "id": "GSJr42ZJKHsi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 4, 4])\n",
        "\n",
        "x = np.where(arr == 4)\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DQxbyp4CKLkv",
        "outputId": "2eedcdbe-9f07-4a51-e264-3b8ff9b7b3de"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(array([3, 5, 6]),)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
        "\n",
        "x = np.where(arr%2 == 0)\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eVWeIaLlKVmO",
        "outputId": "8d994c3e-53f5-4a78-f3f2-ea906a15ee25"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(array([1, 3, 5, 7]),)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
        "\n",
        "x = np.where(arr%2 == 1)\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zD7AobfiKaXs",
        "outputId": "097c7bda-7a97-4444-c8b1-015b63a0ed9a"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(array([0, 2, 4, 6]),)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Search Sorted\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([6, 7, 8, 9])\n",
        "\n",
        "x = np.searchsorted(arr, 7)\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jh3rzVMpKeYZ",
        "outputId": "ebb3e899-5a2e-4b0e-9b5b-64a3fae7187a"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([6, 7, 8, 9])\n",
        "\n",
        "x = np.searchsorted(arr, 7, side='right')\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Trte9F4qKi8E",
        "outputId": "75a88a9e-086c-40df-dc1c-97ff6a773174"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 3, 5, 7])\n",
        "\n",
        "x = np.searchsorted(arr, [2, 4, 6])\n",
        "\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rShHAJ1IKpw5",
        "outputId": "39d8a0ca-5635-48e3-ddf5-05e9eaffc5f4"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "cim5C7eOKxHX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Sorting Arrays\n",
        "Sorting means putting elements in an ordered sequence.\n",
        "\n",
        "Ordered sequence is any sequence that has an order corresponding to elements, like numeric or alphabetical, ascending or descending.\n",
        "\n",
        "The NumPy ndarray object has a function called sort(), that will sort a specified array."
      ],
      "metadata": {
        "id": "euVHMBb1KyB3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([3, 2, 0, 1])\n",
        "\n",
        "print(np.sort(arr))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J2OP1a1eK1Sn",
        "outputId": "70f6df17-8659-44d6-dfca-fea7c26de1e0"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0 1 2 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array(['banana', 'cherry', 'apple'])\n",
        "\n",
        "print(np.sort(arr))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2kjCwt_aK5Lr",
        "outputId": "2de5eec5-204e-4825-c2ae-4f4d01047fc2"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apple' 'banana' 'cherry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([True, False, True])\n",
        "\n",
        "print(np.sort(arr))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z0I3h_9bLCv5",
        "outputId": "5416d9a0-f0cd-447c-979e-99060091dcc3"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[False  True  True]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([[3, 2, 4], [5, 0, 1]])\n",
        "\n",
        "print(np.sort(arr))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qqqmESm6LECz",
        "outputId": "18b46d99-a8ff-42a4-bf58-5a89f447b2e3"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[2 3 4]\n",
            " [0 1 5]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Filtering Arrays\n",
        "Getting some elements out of an existing array and creating a new array out of them is called filtering.\n",
        "\n",
        "In NumPy, you filter an array using a boolean index list.\n",
        "\n",
        "A boolean index list is a list of booleans corresponding to indexes in the array.\n",
        "\n",
        "If the value at an index is True that element is contained in the filtered array, if the value at that index is False that element is excluded from the filtered array.\n",
        "\n"
      ],
      "metadata": {
        "id": "KASE3vPQLWl4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([41, 42, 43, 44])\n",
        "\n",
        "x = [True, False, True, False]\n",
        "\n",
        "newarr = arr[x]\n",
        "\n",
        "print(newarr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aOvceVYrLaH0",
        "outputId": "7536f12a-1a8a-4bf3-b897-a94e7ee7ab3a"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[41 43]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Create a filter array that will return only values higher than 42:\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([41, 42, 43, 44])\n",
        "\n",
        "# Create an empty list\n",
        "filter_arr = []\n",
        "\n",
        "# go through each element in arr\n",
        "for element in arr:\n",
        "  # if the element is higher than 42, set the value to True, otherwise False:\n",
        "  if element > 42:\n",
        "    filter_arr.append(True)\n",
        "  else:\n",
        "    filter_arr.append(False)\n",
        "\n",
        "newarr = arr[filter_arr]\n",
        "\n",
        "print(filter_arr)\n",
        "print(newarr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3A8gFbJtLkDH",
        "outputId": "a42365c4-db27-4e4e-fbf1-8345cdacb0fa"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[False, False, True, True]\n",
            "[43 44]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Create a filter array that will return only even elements from the original array:\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
        "\n",
        "# Create an empty list\n",
        "filter_arr = []\n",
        "\n",
        "# go through each element in arr\n",
        "for element in arr:\n",
        "  # if the element is completely divisble by 2, set the value to True, otherwise False\n",
        "  if element % 2 == 0:\n",
        "    filter_arr.append(True)\n",
        "  else:\n",
        "    filter_arr.append(False)\n",
        "\n",
        "newarr = arr[filter_arr]\n",
        "\n",
        "print(filter_arr)\n",
        "print(newarr)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mVNsQhkFLu3k",
        "outputId": "b6d8dff0-0a5a-405e-89b7-02fbeb2ebde4"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[False, True, False, True, False, True, False]\n",
            "[2 4 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Creating Filter Directly From Array\n",
        "import numpy as np\n",
        "\n",
        "arr = np.array([41, 42, 43, 44])\n",
        "\n",
        "filter_arr = arr > 42\n",
        "\n",
        "newarr = arr[filter_arr]\n",
        "\n",
        "print(filter_arr)\n",
        "print(newarr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D-0DWiXTL5eD",
        "outputId": "14054451-b9e3-48ca-b07b-79df57198390"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[False False  True  True]\n",
            "[43 44]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
        "\n",
        "filter_arr = arr % 2 == 0\n",
        "\n",
        "newarr = arr[filter_arr]\n",
        "\n",
        "print(filter_arr)\n",
        "print(newarr)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c6QOlkr4MEkm",
        "outputId": "4818e9e0-6d27-4aa0-deb3-6e74fd009ad0"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[False  True False  True False  True False]\n",
            "[2 4 6]\n"
          ]
        }
      ]
    }
  ]
}