numpy_tutorial.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "numpy_Basics.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMQd+1QEG3RyYEWsUGlS+Mt",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/hritik7080/Python-Language./blob/main/numpy_tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ekj-uJz9JH6B"
      },
      "source": [
        "# Numpy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MpUWQvUMJH6C"
      },
      "source": [
        "\n",
        "- NumPy provides Python with an extensive math library capable of performing numerical computations effectively and efficiently.\n",
        "    - Even though Python lists are great on their own, NumPy has a number of key features that give it great advantages over Python lists. One such feature is speed. When performing operations on large arrays NumPy can often perform several orders of magnitude faster than Python lists. This speed comes from the nature of NumPy arrays being memory-efficient and from optimized algorithms used by NumPy for doing arithmetic, statistical, and linear algebra operations.\n",
        "    - Another great feature of NumPy is that it has multidimensional array data structures that can represent vectors and matrices. Another great advantage of NumPy over Python lists is that NumPy has a large number of optimized built-in mathematical functions. These functions allow you to do a variety of complex mathematical computations very fast and with very little code (avoiding the use of complicated loops) making your programs more readable and easier to understand.\n",
        "- At the core of NumPy is the **ndarray**, where nd stands for n-dimensional.\n",
        "    - An ndarray is a multidimensional array of elements **all of the same type**.\n",
        "    - Unlike Python lists, all the elements of an ndarray must be of the same type. If you provide the np.array() function with a Python list that has both integers and strings, NumPy will interpret all elements as strings.\n",
        "    - When we create an ndarray with both floats and integers, NumPy assigns its elements a float64 dtype. This is called **upcasting**. Since all the elements of an ndarray must be of the same type, in this case NumPy upcasts the integers in z to floats in order to avoid losing precision in numerical computations.\n",
        "- We refer to 1D arrays as rank 1 arrays. In general N-Dimensional arrays have rank N. Therefore, we refer to a 2D array as a rank 2 array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": true,
        "trusted": false,
        "id": "AZqojAHaJH6D"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K1WpnVZAJH6G"
      },
      "source": [
        "## Create ndarray"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "LE1oBhGQJH6G",
        "outputId": "a84eb606-91da-4b17-fe47-465ae0a24bde",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Create a 1D ndarray that contains only integers\n",
        "x = np.array([1, 2, 3, 4, 5])\n",
        "print('x = ', x) # x = [1 2 3 4 5]\n",
        "print('x has dimensions:', x.shape) # x has dimensions: (5,)\n",
        "print('The elements in x are of type:', x.dtype) # The elements in x are of type: int64\n",
        "\n",
        "# Create a rank 2 ndarray that only contains integers\n",
        "Y = np.array([[1,2,3],[4,5,6],[7,8,9], [10,11,12]])\n",
        "print('Y has dimensions:', Y.shape) # Y has dimensions: (4, 3)\n",
        "print('Y has a total of', Y.size, 'elements') # Y has a total of 12 elements\n",
        "print('Y is an object of type:', type(Y)) # Y is an object of type: class 'numpy.ndarray'\n",
        "print('The elements in Y are of type:', Y.dtype) # The elements in Y are of type: int64"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x =  [1 2 3 4 5]\n",
            "x has dimensions: (5,)\n",
            "The elements in x are of type: int64\n",
            "Y has dimensions: (4, 3)\n",
            "Y has a total of 12 elements\n",
            "Y is an object of type: <class 'numpy.ndarray'>\n",
            "The elements in Y are of type: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BasNUDnuJH6J"
      },
      "source": [
        "## Create ndarray with dtype"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "fWxmgyU2JH6J",
        "outputId": "eb2afbfc-a6fa-4bdb-bcc6-da82f05c32d3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Specify the dtype when creating the ndarray\n",
        "x = np.array([1.5, 2.2, 3.7, 4.0, 5.9], dtype = np.int64)\n",
        "x"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vK3COyR_JH6L"
      },
      "source": [
        "## Save and load"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "b4_q8CuvJH6M",
        "outputId": "e738f7a3-cfa4-44d4-9d1d-ccd91ccc6cad",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Save the array into a file\n",
        "np.save('my_array', x)\n",
        "\n",
        "# Load the saved array from current directory\n",
        "y = np.load('my_array.npy')\n",
        "y"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LH2Xb9-UJH6P"
      },
      "source": [
        "## Zeros"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "PsBB2hKjJH6Q",
        "outputId": "1340ff4f-2bf2-4b1d-d512-53b96a6258d7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Create ndarray using built-in functions\n",
        "# 3 x 4 ndarray full of zeros\n",
        "# np.zeros(shape)\n",
        "X = np.zeros((3,4))\n",
        "X"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.],\n",
              "       [0., 0., 0., 0.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WzvjbStyJH6S"
      },
      "source": [
        "## Ones"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "vr7p0G2YJH6S",
        "outputId": "468e7778-8bdd-4d02-ebdb-5a2beb01755e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# a 3 x 2 ndarray full of ones\n",
        "# np.ones(shape)\n",
        "X = np.ones((3,2))\n",
        "X"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1.],\n",
              "       [1., 1.],\n",
              "       [1., 1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jh2JDi-aJH6U"
      },
      "source": [
        "## Full"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "xi99au1VJH6U",
        "outputId": "cc57c9da-7299-454e-8e1f-e2b6e20b7100",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# 2 x 3 ndarray full of fives\n",
        "# np.full(shape, constant value)\n",
        "X = np.full((2,3), 5)\n",
        "X"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[5, 5, 5],\n",
              "       [5, 5, 5]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PyfDoVsVJH6X"
      },
      "source": [
        "## Identity Matrix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "kWMdXkD3JH6X",
        "outputId": "69a01a4a-e22e-4baa-a3b3-535de3467c7c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Identity Matrix\n",
        "# Since all Identity Matrices are square, the np.eye() function only takes a single integer as an argument\n",
        "# 5 x 5 Identity matrix\n",
        "X = np.eye(5)\n",
        "X"
      ],
      "execution_count": 8,
      "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": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QlTbyi5gJH6Z"
      },
      "source": [
        "## Diagonal Matrix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "IwdyCP3pJH6a",
        "outputId": "da24e17c-3d98-4280-8b79-eb607a48f96c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Diagonal Matrix\n",
        "# 4 x 4 diagonal matrix that contains the numbers 10,20,30, and 50 on its main diagonal\n",
        "X = np.diag([10,20,30,50])\n",
        "X"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[10,  0,  0,  0],\n",
              "       [ 0, 20,  0,  0],\n",
              "       [ 0,  0, 30,  0],\n",
              "       [ 0,  0,  0, 50]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q6BGJLxSJH6b"
      },
      "source": [
        "## Arange"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "3QFrX-0oJH6b",
        "outputId": "2d113393-1091-49ef-9cc7-41ec588118bf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Arange\n",
        "# rank 1 ndarray that has sequential integers from 0 to 9\n",
        "# x = [0 1 2 3 4 5 6 7 8 9]\n",
        "x = np.arange(10)\n",
        "print(x)\n",
        "\n",
        "# rank 1 ndarray that has sequential integers from 4 to 9\n",
        "# [start, stop)\n",
        "# x = [4 5 6 7 8 9]\n",
        "x = np.arange(4,10)\n",
        "print(x)\n",
        "\n",
        "# rank 1 ndarray that has evenly spaced integers from 1 to 13 in steps of 3.\n",
        "# np.arange(start,stop,step)\n",
        "# x = [ 1 4 7 10 13]\n",
        "x = np.arange(1,14,3)\n",
        "print(x)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n",
            "[4 5 6 7 8 9]\n",
            "[ 1  4  7 10 13]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8KXMEcjeJH6e"
      },
      "source": [
        "## Linspace"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "mqy2bVO4JH6f",
        "outputId": "18d19b19-d7e0-4ae0-894c-d092167c7cbf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Linspace\n",
        "# Even though the np.arange() function allows for non-integer steps,\n",
        "# such as 0.3, the output is usually inconsistent, due to the finite\n",
        "# floating point precision. For this reason, in the cases where\n",
        "# non-integer steps are required, it is usually better to use linspace()\n",
        "# becayse np.linspace() uses the number of elements we want in a\n",
        "# particular interval, instead of the step between values.\n",
        "# linspace returns N evenly spaced numbers over the closed interval [start, stop]\n",
        "# np.linspace(start, stop, N)\n",
        "x = np.linspace(0,25,10)\n",
        "x"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0.        ,  2.77777778,  5.55555556,  8.33333333, 11.11111111,\n",
              "       13.88888889, 16.66666667, 19.44444444, 22.22222222, 25.        ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7fO82s0uJH6h"
      },
      "source": [
        "## Reshape"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "c7rc48bFJH6i",
        "outputId": "a43b84ad-8c16-44fe-a172-41b5364a707a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Reshape\n",
        "# np.reshape(ndarray, new_shape)\n",
        "# converts the given ndarray into the specified new_shape\n",
        "x = np.arange(20)\n",
        "print(x)\n",
        "x = np.reshape(x, (4,5))\n",
        "print(x)\n",
        "# or\n",
        "x = np.arange(20).reshape(4, 5) # does the same thing as above\n",
        "print(x)\n",
        "# and the same thing with with linshape\n",
        "y = np.linspace(0,50,10, endpoint=False).reshape(5,2)\n",
        "print(x)\n",
        "# One great feature about NumPy, is that some functions can also be\n",
        "# applied as methods. This allows us to apply different functions in\n",
        "# sequence in just one line of code"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n",
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]]\n",
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]]\n",
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W6hFkcwVJH6k"
      },
      "source": [
        "## Slicing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "QtjsWOT_JH6k",
        "outputId": "bcb6729d-53f9-4a78-fd02-e13bf9be8f3a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 222
        }
      },
      "source": [
        "# Slicing\n",
        "# ndarray[start:end]\n",
        "# ndarray[start:]\n",
        "# ndarray[:end]\n",
        "# ndarray[<start>:<stop>:<step>]\n",
        "\n",
        "# In methods one and three, the end index is excluded [,)\n",
        "X = np.arange(20).reshape(4, 5)\n",
        "print(X)\n",
        "\n",
        "# select all the elements that are in the 2nd through 4th rows and in the 3rd to 5th columns\n",
        "Z = X[1:4,2:5]\n",
        "print(Z)\n",
        "# or\n",
        "Z = X[1:,2:5]\n",
        "print(Z)\n",
        "\n",
        "# elements = a_list[<start>:<stop>:<step>]\n",
        "# select all the elements in the 3rd row\n",
        "v = X[2,:] # v = [10 11 12 13 14]\n",
        "# select all the elements in the 3rd column\n",
        "q = X[:,2] # q = [ 2 7 12 17]\n",
        "# select all the elements in the 3rd column but return a rank 2 ndarray\n",
        "R = X[:,2:3]\n",
        "'''\n",
        "[[ 2]\n",
        " [ 7]\n",
        " [12]\n",
        " [17]]\n",
        "'''\n",
        "# Note: Slicing creates a view, not a copy\n",
        "# when we make assignments, such as: Z = X[1:4,2:5]\n",
        "# the slice of the original array X is not copied in the variable Z.\n",
        "# Rather, X and Z are now just two different names for the same ndarray.\n",
        "# We say that slicing only creates a view of the original array.\n",
        "# This means if we make changes to Z, X changes as well."
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]]\n",
            "[[ 7  8  9]\n",
            " [12 13 14]\n",
            " [17 18 19]]\n",
            "[[ 7  8  9]\n",
            " [12 13 14]\n",
            " [17 18 19]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'\\n[[ 2]\\n [ 7]\\n [12]\\n [17]]\\n'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6rHtgD77JH6l"
      },
      "source": [
        "## Random"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "Tagf-k9YJH6l",
        "outputId": "e69370fd-3fb0-4070-b7f0-76964f8c7845",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Random\n",
        "# 3 x 3 ndarray with random floats in the half-open interval [0.0, 1.0).\n",
        "# np.random.random(shape)\n",
        "X = np.random.random((3,3))\n",
        "print(X)\n",
        "# np.random.randint(start, stop, size = shape)\n",
        "# [start, stop)\n",
        "X = np.random.randint(4,15,size=(3,2))\n",
        "print(X)\n",
        "\n",
        "# create ndarrays with random numbers that satisfy certain statistical properties\n",
        "# 1000 x 1000 ndarray of random floats drawn from normal (Gaussian)\n",
        "# distribution with a mean of zero and a standard deviation of 0.1.\n",
        "# np.random.normal(mean, standard deviation, size=shape)\n",
        "X = np.random.normal(0, 0.1, size=(1000,1000))\n",
        "print(X)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0.43845368 0.99289994 0.44315462]\n",
            " [0.40951401 0.11678369 0.5819038 ]\n",
            " [0.99438929 0.09409864 0.43609498]]\n",
            "[[14 12]\n",
            " [14  5]\n",
            " [10 14]]\n",
            "[[ 0.1445697   0.03927377 -0.0297958  ...  0.14023357  0.07377586\n",
            "  -0.04130793]\n",
            " [ 0.08078575 -0.06714072  0.03725867 ...  0.05551792  0.02099979\n",
            "  -0.00164182]\n",
            " [ 0.04340353  0.05485571  0.17389658 ...  0.10650408 -0.0179168\n",
            "   0.22622715]\n",
            " ...\n",
            " [-0.13590457 -0.05186713  0.05616719 ...  0.19134296  0.00906385\n",
            "  -0.0018744 ]\n",
            " [-0.16751109 -0.06221022  0.03329195 ... -0.04284983  0.15599559\n",
            "  -0.16125631]\n",
            " [ 0.0186614   0.04312911  0.03436845 ... -0.09457534 -0.12060657\n",
            "  -0.01197778]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pa2kqlO4JH6n"
      },
      "source": [
        "## Mutability"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "-_RP1Q2NJH6n",
        "outputId": "996c5a5b-86d8-4037-86e3-b481187e0d6a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Mutability\n",
        "# Change ndarray\n",
        "x[3] = 20\n",
        "print(x)\n",
        "X[0,0] = 20\n",
        "print(X)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [20 20 20 20 20]]\n",
            "[[ 2.00000000e+01  3.92737652e-02 -2.97957972e-02 ...  1.40233575e-01\n",
            "   7.37758607e-02 -4.13079270e-02]\n",
            " [ 8.07857534e-02 -6.71407183e-02  3.72586695e-02 ...  5.55179230e-02\n",
            "   2.09997912e-02 -1.64182223e-03]\n",
            " [ 4.34035252e-02  5.48557091e-02  1.73896584e-01 ...  1.06504080e-01\n",
            "  -1.79168009e-02  2.26227150e-01]\n",
            " ...\n",
            " [-1.35904566e-01 -5.18671265e-02  5.61671928e-02 ...  1.91342963e-01\n",
            "   9.06385073e-03 -1.87439581e-03]\n",
            " [-1.67511090e-01 -6.22102202e-02  3.32919531e-02 ... -4.28498257e-02\n",
            "   1.55995586e-01 -1.61256306e-01]\n",
            " [ 1.86613960e-02  4.31291093e-02  3.43684465e-02 ... -9.45753360e-02\n",
            "  -1.20606569e-01 -1.19777815e-02]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7F1I0LBsJH6q"
      },
      "source": [
        "## Delete"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "VYrqNk9TJH6q",
        "outputId": "3b0f79be-af3f-4a01-a231-396a83a53cae",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Delete\n",
        "# np.delete(ndarray, elements, axis)\n",
        "x = np.array([1, 2, 3, 4, 5])\n",
        "print(x)\n",
        "# delete the first and fifth element of x\n",
        "x = np.delete(x, [0,4])\n",
        "print(x)\n",
        "\n",
        "Y = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "print(Y)\n",
        "# delete the first row of Y\n",
        "w = np.delete(Y, 0, axis=0)\n",
        "print(w)\n",
        "# delete the first and last column of Y\n",
        "v = np.delete(Y, [0,2], axis=1)\n",
        "print(v)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3 4 5]\n",
            "[2 3 4]\n",
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "[[4 5 6]\n",
            " [7 8 9]]\n",
            "[[2]\n",
            " [5]\n",
            " [8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PM_tcbF3JH6s"
      },
      "source": [
        "## Append"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "LPn_XJmVJH6t",
        "outputId": "5ea8f105-8d6f-4340-8851-86c405d5e8e6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Append\n",
        "# np.append(ndarray, elements, axis)\n",
        "# append the integer 6 to x\n",
        "x = np.append(x, 6)\n",
        "print(x)\n",
        "# append the integer 7 and 8 to x\n",
        "x = np.append(x, [7,8])\n",
        "print(x)\n",
        "# append a new row containing 7,8,9 to y\n",
        "v = np.append(Y, [[10,11,12]], axis=0)\n",
        "print(v)\n",
        "# append a new column containing 9 and 10 to y\n",
        "q = np.append(Y,[[13],[14],[15]], axis=1)\n",
        "print(q)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2 3 4 6]\n",
            "[2 3 4 6 7 8]\n",
            "[[ 1  2  3]\n",
            " [ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]]\n",
            "[[ 1  2  3 13]\n",
            " [ 4  5  6 14]\n",
            " [ 7  8  9 15]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i4k1lXqlJH6v"
      },
      "source": [
        "## Insert"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "DMrB2DXPJH6x",
        "outputId": "f5497e0e-500c-40f6-ef4c-93cfd1ac369d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Insert\n",
        "# np.insert(ndarray, index, elements, axis)\n",
        "# inserts the given list of elements to ndarray right before\n",
        "# the given index along the specified axis\n",
        "x = np.array([1, 2, 5, 6, 7])\n",
        "print(x)\n",
        "\n",
        "Y = np.array([[1,2,3],[7,8,9]])\n",
        "print(Y) # insert the integer 3 and 4 between 2 and 5 in x. \n",
        "\n",
        "x = np.insert(x,2,[3,4]) # insert a row between the first and last row of Y\n",
        "print(x)\n",
        "\n",
        "w = np.insert(Y,1,[4,5,6],axis=0) # insert a column full of 5s between the first and second column of Y\n",
        "print(w)\n",
        "\n",
        "v = np.insert(Y,1,5, axis=1)\n",
        "print(v)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 5 6 7]\n",
            "[[1 2 3]\n",
            " [7 8 9]]\n",
            "[1 2 3 4 5 6 7]\n",
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "[[1 5 2 3]\n",
            " [7 5 8 9]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5jtsJ4uuJH60"
      },
      "source": [
        "## Stacking"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "nXkJECyeJH60",
        "outputId": "fe69c796-e0d5-429d-99a6-71fc94869c5e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Stacking\n",
        "# NumPy also allows us to stack ndarrays on top of each other,\n",
        "# or to stack them side by side. The stacking is done using either\n",
        "# the np.vstack() function for vertical stacking, or the np.hstack()\n",
        "# function for horizontal stacking. It is important to note that in\n",
        "# order to stack ndarrays, the shape of the ndarrays must match.\n",
        "x = np.array([1,2])\n",
        "print(x)\n",
        "\n",
        "Y = np.array([[3,4],[5,6]])\n",
        "print(Y)\n",
        "\n",
        "z = np.vstack((x,Y)) # [[1,2], [3,4], [5,6]]\n",
        "print(z)\n",
        "\n",
        "w = np.hstack((Y,x.reshape(2,1))) # [[3,4,1], [5,6,2]]\n",
        "print(w)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2]\n",
            "[[3 4]\n",
            " [5 6]]\n",
            "[[1 2]\n",
            " [3 4]\n",
            " [5 6]]\n",
            "[[3 4 1]\n",
            " [5 6 2]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Gh3jEzwJH62"
      },
      "source": [
        "## Copy"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "7ztL65PlJH62",
        "outputId": "0d1acd4e-b528-4504-fa23-a886699f44df",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Copy\n",
        "# if we want to create a new ndarray that contains a copy of the\n",
        "# values in the slice we need to use the np.copy()\n",
        "# create a copy of the slice using the np.copy() function\n",
        "Z = np.copy(X[1:4,2:5])\n",
        "print(Z)\n",
        "#  create a copy of the slice using the copy as a method\n",
        "W = X[1:4,2:5].copy()\n",
        "print(W)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0.03725867 -0.0739119   0.04639753]\n",
            " [ 0.17389658  0.00308549 -0.09548212]\n",
            " [-0.11382037 -0.33969092 -0.11566186]]\n",
            "[[ 0.03725867 -0.0739119   0.04639753]\n",
            " [ 0.17389658  0.00308549 -0.09548212]\n",
            " [-0.11382037 -0.33969092 -0.11566186]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SDfzCqRbJH64"
      },
      "source": [
        "## Extract elements along the diagonal"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_kg_hide-output": false,
        "trusted": false,
        "id": "TLwrsLAmJH64"
      },
      "source": [
        "# Extract elements along the diagonal\n",
        "d0 = np.diag(X)\n",
        "# As default is k=0, which refers to the main diagonal.\n",
        "# Values of k > 0 are used to select elements in diagonals above\n",
        "# the main diagonal, and values of k < 0 are used to select elements\n",
        "# in diagonals below the main diagonal.\n",
        "d1 = np.diag(X, k=1)\n",
        "d2 = np.diag(X, k=-1)"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S6BUb6vAJH66"
      },
      "source": [
        "## Find Unique Elements"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": false,
        "id": "wkBKiCA3JH67",
        "outputId": "81f4af1c-e4ce-4b8d-c004-13f654a87dd8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Find Unique Elements in ndarray\n",
        "u = np.unique(X)\n",
        "print(u)"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[-0.50333694 -0.46353737 -0.46284834 ...  0.47422659  0.48601592\n",
            " 20.        ]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GefmZ6q3JH69"
      },
      "source": [
        "## Boolean Indexing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": false,
        "id": "hVpPAZDvJH69",
        "outputId": "b524f340-31ba-4c6f-ed98-213faedea852",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Boolean Indexing\n",
        "X = np.arange(25).reshape(5, 5)\n",
        "print('The elements in X that are greater than 10:', X[X > 10])\n",
        "print('The elements in X that less than or equal to 7:', X[X <= 7])\n",
        "print('The elements in X that are between 10 and 17:', X[(X > 10) & (X < 17)])\n",
        "\n",
        "# use Boolean indexing to assign the elements that\n",
        "# are between 10 and 17 the value of -1\n",
        "X[(X > 10) & (X < 17)] = -1"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The elements in X that are greater than 10: [11 12 13 14 15 16 17 18 19 20 21 22 23 24]\n",
            "The elements in X that less than or equal to 7: [0 1 2 3 4 5 6 7]\n",
            "The elements in X that are between 10 and 17: [11 12 13 14 15 16]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ORR5m7JXJH6-"
      },
      "source": [
        "## Set Operations"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": false,
        "id": "BJMgAjuJJH6-",
        "outputId": "a6ecc437-f9e3-4da9-c0ec-12bbcefb2611",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Set Operations\n",
        "x = np.array([1,2,3,4,5])\n",
        "y = np.array([6,7,2,8,4])\n",
        "print('The elements that are both in x and y:', np.intersect1d(x,y))\n",
        "print('The elements that are in x that are not in y:', np.setdiff1d(x,y))\n",
        "print('All the elements of x and y:',np.union1d(x,y))"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The elements that are both in x and y: [2 4]\n",
            "The elements that are in x that are not in y: [1 3 5]\n",
            "All the elements of x and y: [1 2 3 4 5 6 7 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kDshE_AzJH7A"
      },
      "source": [
        "## Sorting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": false,
        "id": "yDHClHV1JH7A",
        "outputId": "0e5388c2-4b3b-4063-f418-b6d9fa3b6b3a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Sorting\n",
        "# When used as a function, it doesn't change the original ndarray\n",
        "s = np.sort(x)\n",
        "print(s)\n",
        "# When used as a method, the original array will be sorted\n",
        "x.sort()\n",
        "\n",
        "# sort x but only keep the unique elements in x\n",
        "s = np.sort(np.unique(x))\n",
        "print(s)\n",
        "\n",
        "# sort the columns of X\n",
        "s = np.sort(X, axis = 0)\n",
        "print(s)\n",
        "\n",
        "# sort the rows of X\n",
        "s = np.sort(X, axis = 1)\n",
        "print(s)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 3 4 5]\n",
            "[1 2 3 4 5]\n",
            "[[-1 -1 -1 -1 -1]\n",
            " [ 0 -1  2  3  4]\n",
            " [ 5  1  7  8  9]\n",
            " [10  6 17 18 19]\n",
            " [20 21 22 23 24]]\n",
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [-1 -1 -1 -1 10]\n",
            " [-1 -1 17 18 19]\n",
            " [20 21 22 23 24]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B7hBgJXVJH7C"
      },
      "source": [
        "## Math Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": false,
        "id": "uoS08pLyJH7D",
        "outputId": "6495a78f-6143-4f6d-d13b-808f2f8521fb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# NumPy allows element-wise operations on ndarrays as well as\n",
        "# matrix operations. In order to do element-wise operations,\n",
        "# NumPy sometimes uses something called Broadcasting.\n",
        "# Broadcasting is the term used to describe how NumPy handles\n",
        "# element-wise arithmetic operations with ndarrays of different shapes.\n",
        "# For example, broadcasting is used implicitly when doing arithmetic\n",
        "# operations between scalars and ndarrays.\n",
        "x = np.array([1,2,3,4])\n",
        "y = np.array([5.5,6.5,7.5,8.5])\n",
        "np.add(x,y)\n",
        "np.subtract(x,y)\n",
        "np.multiply(x,y)\n",
        "np.divide(x,y)\n",
        "\n",
        "# in order to do these operations the shapes of the ndarrays\n",
        "# being operated on, must have the same shape or be broadcastable\n",
        "X = np.array([1,2,3,4]).reshape(2,2)\n",
        "Y = np.array([5.5,6.5,7.5,8.5]).reshape(2,2)\n",
        "np.add(X,Y)\n",
        "np.subtract(X,Y)\n",
        "np.multiply(X,Y)\n",
        "np.divide(X,Y)\n",
        "\n",
        "# apply mathematical functions to all elements of an ndarray at once\n",
        "np.exp(x)\n",
        "np.sqrt(x)\n",
        "np.power(x,2)"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1,  4,  9, 16])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yv6HCAEgJH7D"
      },
      "source": [
        "## Statistical Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": false,
        "id": "qPL7N_EnJH7E",
        "outputId": "b8d55681-08e7-4ba7-caf7-3ac08d19efcc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Statistical Functions\n",
        "print('Average of all elements in X:', X.mean())\n",
        "print('Average of all elements in the columns of X:', X.mean(axis=0))\n",
        "print('Average of all elements in the rows of X:', X.mean(axis=1))\n",
        "print()\n",
        "print('Sum of all elements in X:', X.sum())\n",
        "print('Standard Deviation of all elements in X:', X.std())\n",
        "print('Median of all elements in X:', np.median(X))\n",
        "print('Maximum value of all elements in X:', X.max())\n",
        "print('Minimum value of all elements in X:', X.min())"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Average of all elements in X: 2.5\n",
            "Average of all elements in the columns of X: [2. 3.]\n",
            "Average of all elements in the rows of X: [1.5 3.5]\n",
            "\n",
            "Sum of all elements in X: 10\n",
            "Standard Deviation of all elements in X: 1.118033988749895\n",
            "Median of all elements in X: 2.5\n",
            "Maximum value of all elements in X: 4\n",
            "Minimum value of all elements in X: 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zPmLI3pHJH7G"
      },
      "source": [
        "## Broadcasting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": false,
        "id": "aEX3vF5gJH7G",
        "outputId": "61634a9a-3dbc-4e2d-f227-39c3ba7e9268",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Broadcasting\n",
        "# NumPy is working behind the scenes to broadcast 3 along the ndarray\n",
        "# so that they have the same shape. This allows us to add 3 to each\n",
        "# element of X with just one line of code.\n",
        "print(4*X)\n",
        "print(4+X)\n",
        "print(4-X)\n",
        "print(4/X)\n",
        "# NumPy is able to add 1 x 3 and 3 x 1 ndarrays to 3 x 3 ndarrays\n",
        "# by broadcasting the smaller ndarrays along the big ndarray so that\n",
        "# they have compatible shapes. In general, NumPy can do this provided\n",
        "# that the smaller ndarray can be expanded to the shape of the larger\n",
        "# ndarray in such a way that the resulting broadcast is unambiguous.\n",
        "x = np.array([1,2,3])\n",
        "Y = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "Z = np.array([1,2,3]).reshape(3,1)\n",
        "print(x + Y)\n",
        "print(Z + Y)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 4  8]\n",
            " [12 16]]\n",
            "[[5 6]\n",
            " [7 8]]\n",
            "[[3 2]\n",
            " [1 0]]\n",
            "[[4.         2.        ]\n",
            " [1.33333333 1.        ]]\n",
            "[[ 2  4  6]\n",
            " [ 5  7  9]\n",
            " [ 8 10 12]]\n",
            "[[ 2  3  4]\n",
            " [ 6  7  8]\n",
            " [10 11 12]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-eFyJwL2NFMt"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}