NumPy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **اللهم لا سهل إلا ما جعلته سهلا وأنت تجعل الصعب إن شئت سهلا**\n",
        "# **اللهم ارزقنا الفهم**"
      ],
      "metadata": {
        "id": "e4pwh3GOIDZ9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Let's Start our story with Python Lists**"
      ],
      "metadata": {
        "id": "tRdd4KUEP4MB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lists used for store multiple/ collection of elements.\n",
        "\n",
        "---\n",
        "\n",
        "Python Lists are:-\n",
        "\n",
        "\n",
        "*   Ordered/ Indexing\n",
        "*   Mutable\n",
        "*   Heterogeneous >> Store Different Data Types\n",
        "*   Dynamic >> Size is changable >> Lists can grow or shrink as needed\n",
        "\n"
      ],
      "metadata": {
        "id": "cUvjwfEqQRWf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **1. Creating a list**"
      ],
      "metadata": {
        "id": "YmxZqVzQfDig"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.1 Using Square Brackets []\n",
        "\n",
        "# First Initialize empty list\n",
        "my_list = []\n",
        "# Filling the list with elements\n",
        "my_list = ['Ahmed', 'Sara', 1, 303]\n",
        "my_list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Dpp-7QuNSf92",
        "outputId": "028300c2-4405-41b7-e9fe-bac1f605273e"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Ahmed', 'Sara', 1, 303]"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# OR you can skip the step of initialization and put elements direct <as u like>\n",
        "my_list1 = ['Ahmed', 'Sara', 1, 303]\n",
        "my_list1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "FdVDqSR_VlCy",
        "outputId": "341f8308-d236-4ad2-9998-087c0b211c5b"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Ahmed', 'Sara', 1, 303]"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.2 Creating a list Using list() constructor\n",
        "my_list2 = list(('Ahmed', 'Sara', 1, 303)) # >> We used douple parentheses!!\n",
        "my_list2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "2OXIeLPiWDbp",
        "outputId": "def4ff65-5ac3-49b6-e2a5-e6506a2209cf"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Ahmed', 'Sara', 1, 303]"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "''' Why we used douple parentheses in the previous step not just only one??\n",
        "Try to code this and check the output:\n",
        "my_list2 = list('Ahmed', 'Sara', 1, 303)\n",
        "'''"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "Bt1yySaFYH7A",
        "outputId": "714285f5-1e61-40e4-829b-814152ecc397"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\" Why we used douple parentheses in the previous step not just only one??\\nTry to code this and check the output:\\nmy_list2 = list('Ahmed', 'Sara', 1, 303)\\n\""
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "''' Now let's explore this line >> my_list2 = list(('Ahmed', 'Sara', 1, 303))\n",
        "1. The inner parentheses () define a tuple ('Ahmed', 'Sara', 1, 303)\n",
        "2. The list() constructor takes this tuple as a single argument\n",
        "3. It converts the tuple into a list: ['Ahmed', 'Sara', 1, 303]'''"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "DKztyyhcaOD9",
        "outputId": "5f4aa9c6-6589-4780-8a1d-b0f12878c4e4"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\" Now let's explore this line >> my_list2 = list(('Ahmed', 'Sara', 1, 303))\\n1. The inner parentheses () define a tuple ('Ahmed', 'Sara', 1, 303)\\n2. The list() constructor takes this tuple as a single argument\\n3. It converts the tuple into a list: ['Ahmed', 'Sara', 1, 303]\""
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The douple parentheses not special\n",
        "\n",
        "# We can use range\n",
        "my_list3 = list(range(1,5))\n",
        "my_list3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "iid5ldCccA8U",
        "outputId": "683c85b1-9382-4a9b-9f41-1f56efcfa633"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can use a set\n",
        "my_list4 = list({'Ahmed', 'Sara', 1, 303}) # Sets removes duplicates so when we creating a list by a set the duplicates are removed\n",
        "my_list4"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "RFEs80AZc6OC",
        "outputId": "1d07f06f-bab4-4c65-8048-fa78403e6765"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Sara', 303, 1, 'Ahmed']"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_list5 = list({'Ahmed', 'Ahmed', '12','Sara', 1, 303})\n",
        "my_list5"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "3lph3FCuec7g",
        "outputId": "b46bee2f-7c7c-417a-d97e-0aab3b02578d"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Sara', 1, 'Ahmed', '12', 303]"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2. Accessing an element by Indexing or Slicing ''Range of Indexes''**"
      ],
      "metadata": {
        "id": "bsP_hOPlfJDW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Access elements by Indexing >> 2 ways by the index of the 1st element 0 or by the index of the last element -1\n",
        "my_list6 = ['a', 'b', 'c', 0, 'd', 101,'e']\n",
        "print(my_list6[1])\n",
        "print(my_list6[-3]) # Negative Indexing"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "daF3p1bke3qv",
        "outputId": "41713873-a538-4479-bcae-7578cddf5be1"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b\n",
            "d\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Access elements by slicing [start:end+1]\n",
        "my_list6[1:5] # >> That will access from element with Index 1 to the element with Index 4"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "b39d9Jrtg_fO",
        "outputId": "c63ef780-6783-4c46-9347-2eec5ee96e85"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['b', 'c', 0, 'd']"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# my_list6[0:4] Instead of write that to access from the 1st element u can use the next line instead\n",
        "my_list6[:4] # >> That will access from element with Index 0 to the element with Index 3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "wKoEJ3nojAdE",
        "outputId": "fa551085-6611-42f1-eda9-408d36e75228"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'c', 0]"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_list6[2:] # >> That will access from element with Index 2 to the last element"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Q5fhps5Jjdgj",
        "outputId": "40968569-3bf5-405c-d353-117b9cc853b3"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['c', 0, 'd', 101, 'e']"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# You can also use negative indexing here\n",
        "my_list6[-4:-1] # >> That will access from element with Index -4 to the element with Index -2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "8fC-wXA1j5qT",
        "outputId": "4829affa-dd02-482f-d2ab-70314cdf2925"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 'd', 101]"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **3. Adding elements to the list**"
      ],
      "metadata": {
        "id": "9LuoBUUrnFC3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. **.append():** Adds a single element at the end\n",
        "2. **.extend():** Adds multiple elements at the end\n",
        "3. **.insert():** Adds an element at a specified position"
      ],
      "metadata": {
        "id": "1xac8ykF47EA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list7 = ['a', 'b', 'c', 0, 'd', 101,'e']\n",
        "my_list7.append(\"False\")\n",
        "my_list7"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "xlNwM-yCnxgO",
        "outputId": "d01f8d6a-5d9d-43a6-991e-2e94b29a8999"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'c', 0, 'd', 101, 'e', 'False']"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_list7.extend([11, 'g'])\n",
        "my_list7"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "DoosH4ovn8v-",
        "outputId": "503ef3c2-ef39-4270-d9f7-1a885eabbb36"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'c', 0, 'd', 101, 'e', 'False', 11, 'g']"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_list7.insert(2, 'a') # Insert Ahmed at the index 2 and shift the other elements that was from index 2 to the end\n",
        "my_list7"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "cFsTHR2RoNDu",
        "outputId": "c6ca6ba6-8336-4b1b-9f2e-e6c8a8ac8d6a"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'a', 'c', 0, 'd', 101, 'e', 'False', 11, 'g']"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **4. Removing elements from the list**"
      ],
      "metadata": {
        "id": "VvDv79ZwKapZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. **.remove():** Removes the first occurrence of a value\n",
        "2. **.pop():** Removes an element by index (default: last element)\n",
        "3. **.del:** Deletes an element by index or the entire list\n",
        "4. **.clear():** Removes all elements from the list"
      ],
      "metadata": {
        "id": "cyQW2yo45LwP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_list7.remove('a') # Removes the first occurrence of the value 'a'\n",
        "my_list7"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "y7zQgyV3Ms2l",
        "outputId": "e20e0ff9-dfd4-4a07-993d-959b1c0e97af"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['b', 'a', 'c', 0, 'd', 101, 'e', 'False', 11, 'g']"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_list7.pop() # Removes the last element that is with index -1 : 'g'\n",
        "my_list7"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "m41nqvrpNgYv",
        "outputId": "616e3026-58c6-46fa-8da5-db42ce64b0b6"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['b', 'a', 'c', 0, 'd', 101, 'e', 'False', 11]"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_list7.pop(2) # Removes the element with index 2 : 'Ahmed'\n",
        "my_list7"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "-K7zrPBzNpm6",
        "outputId": "27ff7d61-1169-4852-94c0-f210cf6d68fc"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['b', 'a', 0, 'd', 101, 'e', 'False', 11]"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "l0 = my_list7.pop(0) # >> What should be the value of the variable l0? what had been stored in it?"
      ],
      "metadata": {
        "id": "auAppta5N9oD"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "l0"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "TlzhKVdOPM3L",
        "outputId": "969bf568-3731-4331-f790-65bca5986b94"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'b'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_list7"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "GxgUoGTrPPgP",
        "outputId": "1dfac4c6-66b8-4cb1-ed21-8c40a3c86ce0"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 0, 'd', 101, 'e', 'False', 11]"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Ok what about del() method?\n",
        "del my_list7[-2] # Removes the element with index -2 : 'False'\n",
        "my_list7"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "sRQAkKLXQNJM",
        "outputId": "f1ed8116-dd77-4c41-c7a2-0074f37d6663"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 0, 'd', 101, 'e', 11]"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# del my_list7 # Deletes the entire list"
      ],
      "metadata": {
        "id": "AftEJ_a-VHY-"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_list7.clear() # Removes all elements from the list\n",
        "my_list7"
      ],
      "metadata": {
        "id": "ZYMTYOENUWLl",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "021fa951-89f4-4f7c-e28c-98ddbe755bff"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **5. Operations on lists**"
      ],
      "metadata": {
        "id": "IdujxzmNWSzE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **1. Joining/ Concatenation & Repeating lists**"
      ],
      "metadata": {
        "id": "qU8jmWOgWZmc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Joining lists\n",
        "list1 = [1, 2, 3]\n",
        "list2 = ['a', 'b', 'c']\n",
        "list3 = list1 + list2\n",
        "list3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "BMLrnAQyXJdD",
        "outputId": "0f2e8496-55cc-4a83-a834-a1f90658c89b"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 'a', 'b', 'c']"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "He put the 1st list elements, then the second one elements"
      ],
      "metadata": {
        "id": "A9z_KR7FbhRW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Repeating lists >> list* num of times u want to repeat it\n",
        "list4 = list1 * 3\n",
        "list4"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Onw9xuc0bdVM",
        "outputId": "adecbad0-ffed-4344-d7bf-30ef6d416b59"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 1, 2, 3, 1, 2, 3]"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2. Sorting and Reversing**"
      ],
      "metadata": {
        "id": "YXD7UXVSObb0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Sorting >> Arranging elements of list that is by .sort() method\n",
        "numbers = [34, 23, 67, 100, 88, 2]\n",
        "numbers.sort()\n",
        "numbers"
      ],
      "metadata": {
        "id": "-Cv6GdBrcJpo",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "1c23bbf9-6602-4e1c-914f-d8c494320ec3"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 23, 34, 67, 88, 100]"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "By default it sorts in an ascending order == from smaller to bigger elements"
      ],
      "metadata": {
        "id": "_1syLsnCP9DC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Sorting in descending order\n",
        "numbers.sort(reverse=True) # by making the argument reverse = True\n",
        "numbers"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "hiVMUMa-PSFR",
        "outputId": "ca25ffb5-27dc-4572-81a6-6a26bbe2d2fe"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[100, 88, 67, 34, 23, 2]"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Reversing >> reverse the order of a list by reverse() method\n",
        "numbers.reverse()\n",
        "numbers"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Bm3SKArhRhq7",
        "outputId": "def8d40c-5bb1-454c-a377-b1dd4dd5c146"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 23, 34, 67, 88, 100]"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **3. Iterating through lists**"
      ],
      "metadata": {
        "id": "qE9JSokjT_bO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1. You can loop through the list items by using a for loop\n",
        "for x in numbers:\n",
        "  print(x*2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "kagqLzsAR3OJ",
        "outputId": "eab7e18d-0c84-4f21-b5ac-d699093c507d"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "46\n",
            "68\n",
            "134\n",
            "176\n",
            "200\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2. Using enumerate() function\n",
        "avengers = ['Iron Man', 'Captain America', 'Thor', 'Hulk']\n",
        "for index, value in enumerate(avengers):\n",
        "  print(index, value)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "kTMCDHRcUXSY",
        "outputId": "7fd53d0f-2863-4c60-db3d-ad0155fcc847"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 Iron Man\n",
            "1 Captain America\n",
            "2 Thor\n",
            "3 Hulk\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "By default it starts from 0 indexing and u can change it as u like"
      ],
      "metadata": {
        "id": "gjqNkuM7Z97m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "avengers = ['Iron Man', 'Captain America', 'Thor', 'Hulk']\n",
        "for index, value in enumerate(avengers, start=1):\n",
        "  print(index, value)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "nV20piv0Yfhb",
        "outputId": "00bad78c-8c61-4a36-bc32-6952a0d0b87e"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 Iron Man\n",
            "2 Captain America\n",
            "3 Thor\n",
            "4 Hulk\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Understanding enumerate function more\n",
        "avengers = ['Iron Man', 'Captain America', 'Thor', 'Hulk']\n",
        "e = enumerate(avengers)\n",
        "print(type(e))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "M5iAv8Ssdqvk",
        "outputId": "2882bc5f-5b15-494a-84fb-056421c4b8c1"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'enumerate'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "e_list = list(e)\n",
        "print(e_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "MEj3T1O5ducj",
        "outputId": "2ffc2867-809c-4b4a-a3e7-ae69897a4c26"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(0, 'Iron Man'), (1, 'Captain America'), (2, 'Thor'), (3, 'Hulk')]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3. Using zip() function >> this function takes the 1st element from the 1st list with the 1st element from the second list and so on\n",
        "avengers = ['Iron Man', 'Captain America', 'Thor', 'Hulk']\n",
        "names = ['Tony Stark', 'Steve Rogers', 'Thor Odinson', 'Bruce Banner']\n",
        "z = zip(avengers, names)\n",
        "print(type(z))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "2ZYHj4ZvbPTq",
        "outputId": "2cbac637-9a70-438a-f7eb-85aa2791cb83"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'zip'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "z_list = list(z)\n",
        "print(z_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "qaPCmgUleDdF",
        "outputId": "4362f25d-0c83-4940-d855-f57d8f94b40f"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[('Iron Man', 'Tony Stark'), ('Captain America', 'Steve Rogers'), ('Thor', 'Thor Odinson'), ('Hulk', 'Bruce Banner')]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Using for loop for iterating over the zip object\n",
        "avengers = ['Iron Man', 'Captain America', 'Thor', 'Hulk']\n",
        "names = ['Tony Stark', 'Steve Rogers', 'Thor Odinson', 'Bruce Banner']\n",
        "for avenger, name in zip(avengers, names):\n",
        "  print(avenger, name)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "G9mZC8h7eEO9",
        "outputId": "fb6573f2-c077-4892-b5b4-a067ba4664f2"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Iron Man Tony Stark\n",
            "Captain America Steve Rogers\n",
            "Thor Thor Odinson\n",
            "Hulk Bruce Banner\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print zip with * >> the splat operator to print all the elements!\n",
        "avengers = ['Iron Man', 'Captain America', 'Thor', 'Hulk']\n",
        "names = ['Tony Stark', 'Steve Rogers', 'Thor Odinson', 'Bruce Banner']\n",
        "z = zip(avengers, names)\n",
        "print(*z)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "8oheeyKXh_Pk",
        "outputId": "5329a8ee-b41e-43ed-859b-73a1302aaef1"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Iron Man', 'Tony Stark') ('Captain America', 'Steve Rogers') ('Thor', 'Thor Odinson') ('Hulk', 'Bruce Banner')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-2pggOPZiGBB"
      },
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python Arrays**"
      ],
      "metadata": {
        "id": "fbChjgV0CkD6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Python doesn't have built-in support for Arrays, but Python Lists can be used instead.\n",
        "2. Array has multiple elements but with the same type, and that is a difference with the list.\n",
        "3. Advantage: Array like list >> doesn't have fixed size, you can expand or shrink it.\n",
        "4. Like list, array is indexed.\n",
        "5. Arrays are best for numeric data and require the specification of a data type.\n"
      ],
      "metadata": {
        "id": "T-XOZVTyCqjB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **1. Creating python Array**"
      ],
      "metadata": {
        "id": "XaYNUM04_MK1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# We can use arrays in python by calling array module\n",
        "import array as arr\n",
        "# Syntax: array(typecode, [initializers])\n",
        "# typecode like >> 'i' for Integer , 'f' for Float , 'd' for Double , 'u' for Unicode character ..etc"
      ],
      "metadata": {
        "id": "5dqCZee687js"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "int_arr = arr.array('i', [1, 2, 3])\n",
        "int_arr"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "MOglFh2fBZsw",
        "outputId": "a2415cc6-1f8e-4c2b-8ee6-3eb531c29d07"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# You can access to any element in array by index\n",
        "int_arr[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "axQIUrnfCrh_",
        "outputId": "9e6211c3-f099-4fa8-b9d3-84b32d0eb722"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2. Operations on Arrays**"
      ],
      "metadata": {
        "id": "2sYYP89_EPC_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Arrays support many operations, similar to lists but are limited to homogeneous data.\n",
        "# 2.1 Adding elements to an array\n",
        "int_arr.append(4) # Adding single element by append\n",
        "int_arr"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "RII80bv2E4zF",
        "outputId": "c52eaa10-a69d-4627-84e4-1905ba344089"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [1, 2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_arr.extend([5, 6]) # Adding multiple elements or you can say that you add array to the original array\n",
        "int_arr"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "lB3Oq_zKGltK",
        "outputId": "6bed1409-27b5-4188-bf44-9802329f9874"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [1, 2, 3, 4, 5, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_arr.insert(0, 5) # Adding an element to a specific location\n",
        "int_arr"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "RDGiiD74HBwb",
        "outputId": "4f95afc1-9c25-434d-f878-cb72b086cb34"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [5, 1, 2, 3, 4, 5, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.2 Removing elements from array\n",
        "int_arr.pop() # Removes the last element >> 6\n",
        "int_arr"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "0Hb9ohAtSBDm",
        "outputId": "0e43dbc1-2caa-45cb-ed6c-e0df2ba1d5d8"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [5, 1, 2, 3, 4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_arr.remove(5) # Removes the first occurrence of the value 5\n",
        "int_arr"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "2SkvEmFVSeZ4",
        "outputId": "6e095f41-c874-4cd5-c01c-717eec1cc71a"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [1, 2, 3, 4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "del int_arr[1] # delete element from a specific location"
      ],
      "metadata": {
        "id": "FBpbjZ7fVlfL"
      },
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "int_arr"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "_v9m4Kl9Y4so",
        "outputId": "efdb96d5-5bb0-4a19-bf42-fbbd6e3ecc95"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [1, 3, 4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.3 Slicing elements\n",
        "int_arr[1:3] # >> slice/ select elements from the element that has index 1 and the element that has index 2\n",
        "# Doesn't take the element in index 3 in consider"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "GcN3m66-SrtM",
        "outputId": "12c2ca3d-6ce9-4898-aae3-922e5359d59e"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_arr[:3] # >> slice/ select elements from the element that has index 0 to the element that has index 2\n",
        "# Doesn't take the element in index 3 in consider"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "NE_G2tUSZs0Q",
        "outputId": "9e4b3b3c-0a61-40a8-f8d9-d5455de01216"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [1, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_arr[2:] # >> slice/ select elements from the element that has index 2 to the last element in array"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "DhE4bdizZ1T_",
        "outputId": "0b5d8282-9a83-471a-f5ba-e77a4aeebc59"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.4 Changing array's element\n",
        "int_arr[0] = -1 # changing the value of the 1st element to be -1 instead of 1\n",
        "int_arr"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Bfe4iI-zaDXh",
        "outputId": "309a5a70-ecfc-4cca-e01a-48e8a9ba6158"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [-1, 3, 4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int_arr[1:] = arr.array('i', [-2, -3, -4]) # changing the value of multiple elements\n",
        "int_arr"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "FZ5fPIwqaw8m",
        "outputId": "11ea7c40-dba4-41d3-c7ce-da70037a33d4"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array('i', [-1, -2, -3, -4])"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Numpy**"
      ],
      "metadata": {
        "id": "y--Rz388gKvq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Why Numpy and how does it difference from python lists?\n",
        "\n",
        "> **Speed:** Numpy is very fast and python lists are very slow.\n",
        "::: NumPy operations are implemented in C, enabling faster execution compared to native Python loops and lists.\n",
        "\n",
        "> **Memory Efficient:** NumPy arrays are more memory-efficient than Python lists because they store data in **contiguous memory locations** and use a **fixed data type** for all elements.\n",
        "\n",
        "> In python lists we can do operations like: Insertion, deletion, appending, concatenation ::: In Numpy you can do all that operations and mooore\n",
        "\n",
        "> Numpy provides Advanced Mathematical and Statistical Functions for:\n",
        "1. Linear algebra\n",
        "2. Statistical analysis (mean, median, mode)\n",
        "3. Mathematical functions\n",
        "\n",
        "> Python lists are primarily support 1D arrays ::: At the other side Numpy supports multi-dimensional arrays, enabling powerful operations on matrices and tensors.\n",
        "\n",
        "> NumPy is the backbone of many other Python libraries, like: Pandas, SciPy, Scikit-learn\n"
      ],
      "metadata": {
        "id": "tjhDLDZ3gRGL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **1. Load Numpy package**"
      ],
      "metadata": {
        "id": "uO_jutqPyjvd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# We use np as a shortcut rather than writing numpy at each time we call numpy package\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "JeLPqby2yg7d"
      },
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **2. Creating Arrays**"
      ],
      "metadata": {
        "id": "G7WV_uZrzej7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.1 1D Array\n",
        "# Numpy as a vector >> as a row\n",
        "a = np.array([1, 2, 3, 4, 5])\n",
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "YES0zKf_zd-j",
        "outputId": "dc67d32e-de6c-437c-81c3-e82d8c81dbfb"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.2 2D Array\n",
        "c = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "c"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "JumTnZgE1JrR",
        "outputId": "ef5ef9e3-6e59-4995-89dc-33d8cee0fe42"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Numpy as a vector >> as a column\n",
        "b = np.array([[1], [2], [3], [4], [5]])\n",
        "b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "0PYeAOW31ax1",
        "outputId": "e5ca6f66-740f-4cd8-f41c-2e570556e706"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1],\n",
              "       [2],\n",
              "       [3],\n",
              "       [4],\n",
              "       [5]])"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Even if there is only one column, as long as there are multiple dimensions, it is considered 2D.\n",
        "\n",
        "[ [1],\n",
        "\n",
        "[2],\n",
        "\n",
        "[3],\n",
        "\n",
        "[4],\n",
        "\n",
        "[5] ]"
      ],
      "metadata": {
        "id": "rlLWeN-o-js6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.3 Multi Dimensional Array >> Tensors\n",
        "d = np.array([[[1, 2, 3], [4, 5, 6]], [[-1, -2, -3], [-4, -5, -6]]])\n",
        "d"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "HQHuXz782T4p",
        "outputId": "23750581-a2d8-47ec-802a-749519139d47"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[ 1,  2,  3],\n",
              "        [ 4,  5,  6]],\n",
              "\n",
              "       [[-1, -2, -3],\n",
              "        [-4, -5, -6]]])"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Discover the shape of the multi dim array : d , by .shape attribute\n",
        "d.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "z-yS0haB2uES",
        "outputId": "a0582263-26dc-48ff-9d05-169a734ea01b"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 2, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> (2, 2, 3) >> 2 matrices, 2 rows, 3 columns"
      ],
      "metadata": {
        "id": "7efpM3fm38fI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Initializing arrays Automaticilly**"
      ],
      "metadata": {
        "id": "nllpzzpstdtj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "z = np.arange(1, 10, 2) # Start at 1, stop before 10, step by 2\n",
        "z"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "T5k5yeqWtl11",
        "outputId": "6a809561-6b0e-48c1-ed1e-591c19ff826d"
      },
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 3, 5, 7, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# All zero matrix\n",
        "np.zeros((2, 3)) # 2 rows, 3 columns"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "G9M5lt-7t8wc",
        "outputId": "3ced2891-7bcd-46ad-f2a1-e095ada24933"
      },
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.]])"
            ]
          },
          "metadata": {},
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# All one matrix\n",
        "np.ones((2, 2, 3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "oW0pFszauHJL",
        "outputId": "77a785d1-b893-4024-d6a5-8b05f6311644"
      },
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[1., 1., 1.],\n",
              "        [1., 1., 1.]],\n",
              "\n",
              "       [[1., 1., 1.],\n",
              "        [1., 1., 1.]]])"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# with specifing dtype\n",
        "np.ones((4, 2, 2), dtype='int32')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "VLCOwiZPufas",
        "outputId": "26d5a13f-c133-477c-d6a0-211fb8ceff94"
      },
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[1, 1],\n",
              "        [1, 1]],\n",
              "\n",
              "       [[1, 1],\n",
              "        [1, 1]],\n",
              "\n",
              "       [[1, 1],\n",
              "        [1, 1]],\n",
              "\n",
              "       [[1, 1],\n",
              "        [1, 1]]], dtype=int32)"
            ]
          },
          "metadata": {},
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Any other number\n",
        "np.full((2, 2), 99)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "DszWe52kupqS",
        "outputId": "af9152a1-ce6d-436a-9f49-e1b2d26e8517"
      },
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[99, 99],\n",
              "       [99, 99]])"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "c"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "IbaHppUjvJBq",
        "outputId": "0c70e251-46b0-4344-ea59-9dd723919ebe"
      },
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# creating an array (full_like)\n",
        "np.full_like(c, 4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "AmxiLlLpvMe5",
        "outputId": "3cfe30b8-630a-4c8d-cc65-db2d5c644a37"
      },
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[4, 4, 4],\n",
              "       [4, 4, 4]])"
            ]
          },
          "metadata": {},
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Another way!\n",
        "np.full(c.shape, 4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "t4lGm3wTvYXS",
        "outputId": "078cff66-8c67-46ae-9390-fb11767bbce0"
      },
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[4, 4, 4],\n",
              "       [4, 4, 4]])"
            ]
          },
          "metadata": {},
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Random decimal numbers\n",
        "np.random.rand(4, 2, 2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "ZQ7bZqiiw4kY",
        "outputId": "edc8a601-7325-4860-ea4d-310210e3f7ec"
      },
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[0.83843565, 0.28610168],\n",
              "        [0.06950281, 0.10393482]],\n",
              "\n",
              "       [[0.00643353, 0.31922458],\n",
              "        [0.51172816, 0.30148315]],\n",
              "\n",
              "       [[0.67308896, 0.99452703],\n",
              "        [0.08953342, 0.73498771]],\n",
              "\n",
              "       [[0.12257549, 0.08071969],\n",
              "        [0.47948853, 0.12826018]]])"
            ]
          },
          "metadata": {},
          "execution_count": 98
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Random numbers (random_sample)\n",
        "np.random.random_sample(c.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "BuIGtATuxClI",
        "outputId": "88768b60-434d-4f68-c23f-8fb9c9dd115e"
      },
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.5499585 , 0.84223079, 0.61723232],\n",
              "       [0.86175485, 0.98480926, 0.31653546]])"
            ]
          },
          "metadata": {},
          "execution_count": 99
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Random Integer numbers\n",
        "np.random.randint(5, size = (3, 3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Tv8XEdp7xcRj",
        "outputId": "9ed75110-3ce6-4f52-fd8d-b618f54d8c33"
      },
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1, 4],\n",
              "       [0, 3, 1],\n",
              "       [3, 3, 2]])"
            ]
          },
          "metadata": {},
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.randint(4, 6, size = (3, 3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "cSxGkLpUyAbw",
        "outputId": "1c932e2c-be03-4af3-9d37-4e7a35a1f889"
      },
      "execution_count": 103,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[5, 4, 4],\n",
              "       [4, 4, 4],\n",
              "       [5, 5, 5]])"
            ]
          },
          "metadata": {},
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Identity matrix\n",
        "np.identity(5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "J3dA5S8uzEy_",
        "outputId": "52ac210b-3deb-4eb5-ea52-05ca80889625"
      },
      "execution_count": 104,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 0., 0., 0., 0.],\n",
              "       [0., 1., 0., 0., 0.],\n",
              "       [0., 0., 1., 0., 0.],\n",
              "       [0., 0., 0., 1., 0.],\n",
              "       [0., 0., 0., 0., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 104
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Repeat array\n",
        "arr = np.array([[1, 2, 3]])\n",
        "r1 = np.repeat(arr, 3, axis = 0) # >> repeat arr on 0(x) axis 3 times\n",
        "print(r1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "ya2OTgyRzMLv",
        "outputId": "38909434-5290-4b8b-ce9b-704fcdc9d7a7"
      },
      "execution_count": 105,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3]\n",
            " [1 2 3]\n",
            " [1 2 3]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "r2 = np.repeat(arr, 3, axis = 1) # >> repeat arr on 1(y) axis 3 times\n",
        "print(r2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "CF4fVWZHzh-G",
        "outputId": "68b2c424-9ac7-4145-de53-97af47af567a"
      },
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 1 1 2 2 2 3 3 3]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **3. Get Dimensions of an array**"
      ],
      "metadata": {
        "id": "Wzc2b81G5sVO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# For 1D array\n",
        "a.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "0oS5M-Hc57Oe",
        "outputId": "edd3ba1c-4306-4db3-f763-e8377b25dca0"
      },
      "execution_count": 102,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5,)"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The output of (num,) represents the output of shape 1D array, num indicates number of elements in the array."
      ],
      "metadata": {
        "id": "rT11PnVe8kTE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# For 2D array\n",
        "b.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "xXdj7rVP6C2N",
        "outputId": "b612ed2c-1603-465e-bb7a-3fe1d98078ee"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "b: It is a 2D array because it has two dimensions:\n",
        "1. Rows: There are 5 rows (one for each list element).\n",
        "2. Columns: There is 1 column (each inner list contains a single element)."
      ],
      "metadata": {
        "id": "cm9o7vK49pEL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "c.shape # 2D array"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "MxyYK02IA8oo",
        "outputId": "c0e0b762-fe68-48f6-914f-baa1eac33dd9"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# For multi Dimensional array\n",
        "d.shape # and we explained above the output"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "jWXW-P-7BLK5",
        "outputId": "55259bb6-7bf1-42fc-c5f5-96b23797c886"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 2, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **4. Get Type**"
      ],
      "metadata": {
        "id": "kztIMFXeBav5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Va7puLIkBe9j",
        "outputId": "e8a063e5-e19e-4117-b97c-0c438a517225"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('int64')"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can also change the type as we want\n",
        "a = np.array([1, 2, 3, 4, 5], dtype='int16')\n",
        "a.dtype"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "zGvTc-kXBs94",
        "outputId": "8551fcce-2c61-47f8-f1fb-b21447948f66"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('int16')"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **5. Get Size**"
      ],
      "metadata": {
        "id": "M8Qi3pD5B8FY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 5.1 Understand the memory usage of individual elements in the array\n",
        "a.itemsize"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "mjbbu_TVCgGA",
        "outputId": "c30eb2eb-918d-4fc9-b624-5fc171f552b0"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> As we set the dtype of a int16: itemsize is the size of a single array element in bytes.\n",
        "\n",
        "> So the size of each int16 element in a takes = 16 / 8 = 2 bytes"
      ],
      "metadata": {
        "id": "TcomLX2BCz2H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 5.2 Calculate the total count of elements\n",
        "a.size"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "4rKg6liZL4Pl",
        "outputId": "571e9ef5-787b-4555-aae8-27b0ef7e823d"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 5.3 Calculate the total size\n",
        "total_size = a.size * a.itemsize\n",
        "total_size"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "H9wspVRhMnLJ",
        "outputId": "24368461-0107-4bfb-efd4-3c2449acf097"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Another way to calculate the total size\n",
        "total_size = a.nbytes\n",
        "total_size"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "NuWJXzFWM6pt",
        "outputId": "ce5ca815-ab9d-482e-e318-f844d6542f0f"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **6. Access/ change a specific elements, rows, columns ..etc**"
      ],
      "metadata": {
        "id": "MgpXT_hIOzlc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])\n",
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "-0yb3jZxPLl0",
        "outputId": "754af4f4-1c12-482f-f929-b503adc63c63"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  2,  3,  4,  5],\n",
              "       [ 6,  7,  8,  9, 10]])"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 6.1 Get a specific element >> name_of_array[index_of_row, index_of_column]\n",
        "x[1, 4]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "-Q8OB5m7RBU9",
        "outputId": "32ed0456-cdf5-4efa-89aa-4b17adb70fe3"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 6.2 Get a specific row\n",
        "x[0, :] # >> 1st row with all elements in it"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Sx48g1gWRify",
        "outputId": "3503e07b-771f-4697-8af0-3d73aadd2686"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 6.3 Get a specific column\n",
        "x[:, -1] # Get the last column with all elements in it"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "pJW2eaYAR905",
        "outputId": "549a72d1-d558-42d0-cb61-c6f42f2a73fe"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 5, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 6.4 Specifing elements [startIndex : endIndex : stepSize]\n",
        "x[1, 0: 5: 2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "XjHgyx44mPZy",
        "outputId": "5d4aa0f9-babe-4169-adf7-89091c1eab35"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 6,  8, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 6.4 Changing the value of an element\n",
        "x[0, 4] = -1\n",
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "T-crVuyAn3H4",
        "outputId": "e4cd046d-ea39-414f-f6d8-202184c8b0de"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  2,  3,  4, -1],\n",
              "       [ 6,  7,  8,  9, 10]])"
            ]
          },
          "metadata": {},
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 6.5 Changing the values of entire column\n",
        "x[:, 2] = 0\n",
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "FbQIQaXjocRP",
        "outputId": "2e8d408f-3a7a-483d-e0f8-de9082960973"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  2,  0,  4, -1],\n",
              "       [ 6,  7,  0,  9, 10]])"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> With 3D"
      ],
      "metadata": {
        "id": "2aCykiwVplAu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y = np.array([[[1, 2, 3], [4, 5, 6]], [[-1, -2, -3], [-4, -5, -6]]])\n",
        "y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Gk7YhZi2poLW",
        "outputId": "f723bbe7-f813-4377-9602-e0f288d378d3"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[ 1,  2,  3],\n",
              "        [ 4,  5,  6]],\n",
              "\n",
              "       [[-1, -2, -3],\n",
              "        [-4, -5, -6]]])"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 6.A Get a specific element\n",
        "y[0, 1, 2] # >> 1st matrix, 2nd row, 3rd column"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "QvPXcHKNpvvG",
        "outputId": "d451ff82-880e-4a77-cd16-988c650ef73b"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 6.B Get a specification of elements\n",
        "y[:, 1, :] # >> 2nd row of all matrices"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "4UcJbGeXqH1t",
        "outputId": "ec3d0449-a4f7-4d24-c9da-58a4ac429e36"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 4,  5,  6],\n",
              "       [-4, -5, -6]])"
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y[:, 0, 0] # >> 1st element of all matrices"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "BDAuqycKqtbM",
        "outputId": "6729212e-408e-4bb2-c5f0-afcc82a145ba"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1, -1])"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 6.C Replace elements\n",
        "y[:, 1, :]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "W29YiFOvq5Nk",
        "outputId": "c69e83e4-f286-41c8-f577-f2c7884babe4"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 4,  5,  6],\n",
              "       [-4, -5, -6]])"
            ]
          },
          "metadata": {},
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y[:, 1, :] = [[9, 9, 9], [8, 8, 8]]\n",
        "y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "7yV-b8VFrIS8",
        "outputId": "46b58313-3969-43f4-e763-7f427164abeb"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[ 1,  2,  3],\n",
              "        [ 9,  9,  9]],\n",
              "\n",
              "       [[-1, -2, -3],\n",
              "        [ 8,  8,  8]]])"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **7. Copying arrays**"
      ],
      "metadata": {
        "id": "6-iDzOnL1ML8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.array([1, 2, 3])\n",
        "b = a\n",
        "b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Vc0skdLA1L2d",
        "outputId": "afcfc0bf-9d0b-4e63-835d-bbf5b5a91fd2"
      },
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b[0] = 100\n",
        "b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "kuFeq4-g1VFc",
        "outputId": "cd959d98-e653-4b30-97d0-2bff6570962d"
      },
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([100,   2,   3])"
            ]
          },
          "metadata": {},
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "QZleU4uq1b8U",
        "outputId": "c08fcdc0-e089-414a-8564-0aa9a0fd8ac0"
      },
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([100,   2,   3])"
            ]
          },
          "metadata": {},
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.array([1, 2, 3])\n",
        "b = a.copy()\n",
        "b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "4iJjvWP-1lnE",
        "outputId": "42a31e37-6286-45e3-cc21-80154262c86c"
      },
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b[0] = 100\n",
        "b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "BodtDTqo1oRs",
        "outputId": "b3bbe61f-557d-4543-c3ab-7e1c21aed6c9"
      },
      "execution_count": 111,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([100,   2,   3])"
            ]
          },
          "metadata": {},
          "execution_count": 111
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "KHROj_Rg1srk",
        "outputId": "28fe3df1-5056-475c-ac9a-947edfc38ad3"
      },
      "execution_count": 112,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 112
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **8. Mathematics**"
      ],
      "metadata": {
        "id": "-OvVfydP182U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.array([1, 2, 3, 4])\n",
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M27CZvTL18cV",
        "outputId": "6dc0c015-9b90-4b4d-8af8-b924656afd47"
      },
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 120
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a +=2\n",
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ugt7JJAk2Tgk",
        "outputId": "ca994003-5f6e-4240-c07a-460558528db0"
      },
      "execution_count": 121,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3, 4, 5, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 121
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a -=2\n",
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TRbH9IwT2ZGs",
        "outputId": "6c7c2d85-ee12-4923-b6d0-112b15c2b886"
      },
      "execution_count": 122,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 122
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a*=2\n",
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z_R8pfur2dVp",
        "outputId": "e90363a9-217f-41af-ffc8-f684e1717e99"
      },
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 4, 6, 8])"
            ]
          },
          "metadata": {},
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a / 2\n",
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3uWf6HJf2f5Y",
        "outputId": "ab26f1b0-5483-4f94-9bdd-27c5a6b1006d"
      },
      "execution_count": 125,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 4, 6, 8])"
            ]
          },
          "metadata": {},
          "execution_count": 125
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a ** 2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KHongUK-3FN7",
        "outputId": "aa685a51-f2ea-46df-8e56-9b8f3b3022e1"
      },
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 4, 16, 36, 64])"
            ]
          },
          "metadata": {},
          "execution_count": 127
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Take sin\n",
        "np.sin(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q_-IPP3C3LTV",
        "outputId": "b424f751-ce9b-4922-b53a-dd8b6c6996fa"
      },
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0.90929743, -0.7568025 , -0.2794155 ,  0.98935825])"
            ]
          },
          "metadata": {},
          "execution_count": 128
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Take cos\n",
        "np.cos(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9v15oUrs3Q5s",
        "outputId": "16fe0e9c-b1e2-42bd-cfc8-a0b64fda85db"
      },
      "execution_count": 129,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.41614684, -0.65364362,  0.96017029, -0.14550003])"
            ]
          },
          "metadata": {},
          "execution_count": 129
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b = np.array([1, 0, 1, 0])\n",
        "a + b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OFNhVu2a27Nk",
        "outputId": "c1e06e90-c3f7-4a21-e548-f38085e20e52"
      },
      "execution_count": 126,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3, 4, 7, 8])"
            ]
          },
          "metadata": {},
          "execution_count": 126
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **9. Linear Algebra**"
      ],
      "metadata": {
        "id": "uv7dDcTO3wS6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.ones((2, 3))\n",
        "print(a)\n",
        "\n",
        "b = np.full((3, 2), 2)\n",
        "print(b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OWfwcl5L3AJk",
        "outputId": "ebb0574d-f537-4e68-b8d4-9dc046df5557"
      },
      "execution_count": 130,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1. 1. 1.]\n",
            " [1. 1. 1.]]\n",
            "[[2 2]\n",
            " [2 2]\n",
            " [2 2]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiply a and b\n",
        "np.matmul(a, b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TOf5ZMeh4ZU3",
        "outputId": "76fa24ca-e3ea-4452-c882-010756e5380b"
      },
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[6., 6.],\n",
              "       [6., 6.]])"
            ]
          },
          "metadata": {},
          "execution_count": 131
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Or you can do that by this way\n",
        "a @ b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yjS_7sRs4jWa",
        "outputId": "fea598f5-2167-418d-998b-94a9a002dff8"
      },
      "execution_count": 132,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[6., 6.],\n",
              "       [6., 6.]])"
            ]
          },
          "metadata": {},
          "execution_count": 132
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the determinant\n",
        "c = np.identity(3)\n",
        "np.linalg.det(c)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y-Un5GZN42yR",
        "outputId": "cd662b36-fdb9-4f21-918a-a78c9cdb126b"
      },
      "execution_count": 133,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {},
          "execution_count": 133
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Vector norm >> distance\n",
        "from numpy.linalg import norm"
      ],
      "metadata": {
        "id": "uVEPuTmO5QpJ"
      },
      "execution_count": 135,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.array([1, 2, 3])\n",
        "norm1 = norm(a, 1) # 1 is for l1 norm >> calc its sum of the absolute values\n",
        "norm1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-lxBrRPM6RNT",
        "outputId": "2c2aef47-f25b-43b7-bb7f-4b74713d8f1f"
      },
      "execution_count": 136,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6.0"
            ]
          },
          "metadata": {},
          "execution_count": 136
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = np.array([1, -2, -3])\n",
        "norm1 = norm(a, 1)\n",
        "norm1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ecIRCFQu6ekq",
        "outputId": "325b1afd-06a9-4a15-bf7c-9f4bdd38307a"
      },
      "execution_count": 137,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6.0"
            ]
          },
          "metadata": {},
          "execution_count": 137
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "norm2 = norm(a, 2) # 2 is for l2 norm >> calc its distance from the origin, it cal by square root of sum of values\n",
        "norm2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dMknW-WE6kSn",
        "outputId": "df4e40d0-9179-4cdb-9705-1ad8d336a85c"
      },
      "execution_count": 138,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.7416573867739413"
            ]
          },
          "metadata": {},
          "execution_count": 138
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# default is l2 if we doesn't specify\n",
        "norm3 = norm(a)\n",
        "norm3"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2pVFfpB360GY",
        "outputId": "d54ef105-f517-4a6a-bb6f-a37e61aa2a87"
      },
      "execution_count": 139,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.7416573867739413"
            ]
          },
          "metadata": {},
          "execution_count": 139
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **10. Statistics**"
      ],
      "metadata": {
        "id": "pAol4HII7ALI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stats = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "stats"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jqA5TZzh7G6p",
        "outputId": "3326ae8c-135c-4273-c9a5-7e61e239ff12"
      },
      "execution_count": 140,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 140
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.min(stats)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q92KTBry7N8A",
        "outputId": "e81f6f6c-6aa3-4258-e500-1952a1719441"
      },
      "execution_count": 141,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 141
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> axis=0: Compute the minimum along columns.\n",
        "\n",
        "> axis=1: Compute the minimum along rows."
      ],
      "metadata": {
        "id": "v8qVSMIZ7fSt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.min(stats, axis = 0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BIrVhZvs7kvg",
        "outputId": "a2559c2e-6628-4b94-d874-5e29d8342004"
      },
      "execution_count": 143,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 143
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.min(stats, axis = 1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tHGlngUU7Qmw",
        "outputId": "57649efd-b2bb-4913-8385-ff6295cda97f"
      },
      "execution_count": 142,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 142
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.max(stats)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JY2kdYio7nY_",
        "outputId": "6f19c596-9b10-4112-f001-15e6c3996f4f"
      },
      "execution_count": 144,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 144
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.max(stats, axis = 0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jLYEf4ui7skA",
        "outputId": "7e3302ce-b23a-4e9d-f046-7152b5804245"
      },
      "execution_count": 145,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([4, 5, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 145
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.sum(stats)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LmgJrqIj7w0Q",
        "outputId": "d3fd2c7a-a589-442c-96ab-2b618ec63650"
      },
      "execution_count": 146,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "21"
            ]
          },
          "metadata": {},
          "execution_count": 146
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.sum(stats, axis = 0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lr_7IyDr73jn",
        "outputId": "0cf45182-0bdb-44ed-abcc-f741aa7def7f"
      },
      "execution_count": 147,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5, 7, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 147
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **11. Reshape Arrays**"
      ],
      "metadata": {
        "id": "3CvOZRYS8hj_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "before = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "before"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nMdnKNS08lZO",
        "outputId": "1c40bb56-e8f2-46a7-e0a6-2b49d8802529"
      },
      "execution_count": 148,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3, 4],\n",
              "       [5, 6, 7, 8]])"
            ]
          },
          "metadata": {},
          "execution_count": 148
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "after = before.reshape((2, 2, 2))\n",
        "after"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gWJjWm_l8ouS",
        "outputId": "1791a69d-f407-4442-ed4d-c3c11bb2877f"
      },
      "execution_count": 149,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[1, 2],\n",
              "        [3, 4]],\n",
              "\n",
              "       [[5, 6],\n",
              "        [7, 8]]])"
            ]
          },
          "metadata": {},
          "execution_count": 149
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **12. Stacking vectors**"
      ],
      "metadata": {
        "id": "t9Zp-LIP9qTW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Stacking vectors** refers to combining multiple vectors (1D arrays) into a higher-dimensional array in NumPy. This operation is typically used to create 2D or higher-dimensional arrays by aligning vectors along rows, columns, or other axes."
      ],
      "metadata": {
        "id": "5hv8-bMF92EG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Horizontal Stacking\n",
        "v1 = np.array([1, 2, 3, 4])\n",
        "v2 = np.array([5, 6, 7, 8])\n",
        "\n",
        "np.hstack([v1, v2, v2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-AUWwlit96v4",
        "outputId": "b47a07a4-82c8-4ca3-ef1d-2bcc3d0db41f"
      },
      "execution_count": 150,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5, 6, 7, 8, 5, 6, 7, 8])"
            ]
          },
          "metadata": {},
          "execution_count": 150
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Vertical Stacking\n",
        "v1 = np.array([1, 2, 3, 4])\n",
        "v2 = np.array([5, 6, 7, 8])\n",
        "\n",
        "np.vstack([v1, v2, v2, v1])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xo2pAfa0-Fn2",
        "outputId": "9d358472-1476-4019-9144-bc41158064de"
      },
      "execution_count": 151,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3, 4],\n",
              "       [5, 6, 7, 8],\n",
              "       [5, 6, 7, 8],\n",
              "       [1, 2, 3, 4]])"
            ]
          },
          "metadata": {},
          "execution_count": 151
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **References:**\n",
        "\n",
        "[W3scools](https://www.w3schools.com/)\n",
        "\n",
        "[GeeksforGeeks](https://www-geeksforgeeks-org.translate.goog/?_x_tr_sl=en&_x_tr_tl=ar&_x_tr_hl=ar&_x_tr_pto=sc&_x_tr_hist=true)\n",
        "\n",
        "[Python NumPy Tutorial for Beginners YT video](https://youtu.be/QUT1VHiLmmI?si=Z8IAoFS2R7adAX7-)"
      ],
      "metadata": {
        "id": "jxTrhZuR5h1-"
      }
    }
  ]
}