Python_Basics_10(NumPy-2).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNBF5i7z5pDEpN1qhcWvLGu",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Dhinesh-Fedor/Python---Basics/blob/main/Python_Basics_10(NumPy-2).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 939
        },
        "id": "d1N5KEa2-Ssj",
        "outputId": "cc74a5ac-28a3-4f8b-d330-b78ead688347"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.72473076 0.8058349  0.31286808 ... 0.70956263 0.62471271 0.9663033 ]\n",
            "[-1.77274222  0.63927832 -1.82100225 ... -0.83526028 -0.09939135\n",
            "  1.70004951]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import matplotlib.pyplot as p #matplotlib => library used to plot distributions\n",
        "import numpy as n\n",
        "\n",
        "s = 100000\n",
        "uniform = n.random.rand(s)\n",
        "normal = n.random.randn(s)\n",
        "\n",
        "print(uniform)\n",
        "print(normal)\n",
        "\n",
        "pdf ,bins,patches = p.hist(uniform,bins = 12,range=(0,1),density = True)\n",
        "p.title('rand : uniform')\n",
        "p.show()\n",
        "\n",
        "pdf ,bins,patches = p.hist(normal,bins = 12,range=(-4,4),density = True)\n",
        "p.title('randn : normal')\n",
        "p.show()\n",
        "\n",
        ""
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#randn function => results normal distribution\n",
        "\n",
        "a = n.random.randn(4)\n",
        "b = n.random.randn(5,6)\n",
        "print('1-D:')\n",
        "print(a)\n",
        "print('2-D:')\n",
        "print(b)\n",
        "\n",
        "#randint() => generates a random integer within the range\n",
        "#syntax => randint(low,high,size)\n",
        "a = n.random.randint(20)\n",
        "print(a)\n",
        "a = n.random.randint(2,20)\n",
        "print(a)\n",
        "a = n.random.randint(1,20,10)\n",
        "print(a)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3wygF2eAFSW9",
        "outputId": "9a0608f8-596c-467f-ea39-5f60f9337d45"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1-D:\n",
            "[ 0.27163508 -0.27586007  0.51620076 -0.1005876 ]\n",
            "2-D:\n",
            "[[-1.05390275  1.03987722 -0.26036899 -1.11073972 -0.32382027 -0.74788345]\n",
            " [-1.20879784 -0.30396749  2.89690872  1.72631173  0.2386309  -0.09047478]\n",
            " [-0.6169962   0.78028142  0.85451575 -0.7000781   1.71550441 -0.54999212]\n",
            " [-1.08169563 -0.50620788  0.25741502  0.07330501 -1.41932597  0.35600176]\n",
            " [-1.06369242 -1.61412172  0.71473629  0.23029152  2.0317892   0.00532303]]\n",
            "7\n",
            "5\n",
            "[ 1 19 17 19 17  9 16  4 16  1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Arthmetic operations\n",
        "a = n.array([(1,2,3,4)])\n",
        "b = n.array([(5,6,7,8)])\n",
        "#addition\n",
        "print(a+b)\n",
        "#subtraction\n",
        "print(\"\\n\",a-b)\n",
        "#multiplication\n",
        "print(\"\\n\",a*b)\n",
        "#division\n",
        "print(\"\\n\",a/b)\n",
        "\n",
        "#Broadcasting\n",
        "e = a+50\n",
        "print(\"\\n\",e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OZ4HwacdG0R5",
        "outputId": "49788353-c300-4cf7-8dd2-0c0d17b321ef"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 6  8 10 12]]\n",
            "\n",
            " [[-4 -4 -4 -4]]\n",
            "\n",
            " [[ 5 12 21 32]]\n",
            "\n",
            " [[0.2        0.33333333 0.42857143 0.5       ]]\n",
            "[[51 52 53 54]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Mathematical functions\n",
        "\n",
        "#square root\n",
        "r = n.sqrt(a)\n",
        "print(r)\n",
        "\n",
        "#exponential\n",
        "q = n.exp(a)\n",
        "print(\"\\n\",q)\n",
        "\n",
        "#Sine\n",
        "sin = n.sin(a)\n",
        "print(\"\\n\",sin)\n",
        "\n",
        "#Cos\n",
        "cos = n.cos(a)\n",
        "print(\"\\n\",cos)\n",
        "\n",
        "#log\n",
        "log = n.log(a)\n",
        "print(\"\\n\",log)\n",
        "\n",
        "#Sum\n",
        "sum = n.sum(a)\n",
        "print(\"\\n\",sum)\n",
        "\n",
        "#Standard deviation\n",
        "std = n.std(a)\n",
        "print(\"\\n\",std)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GbYAZZRIHxBZ",
        "outputId": "7ef10717-5ab3-4626-d9b0-828d0d05ef32"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1.         1.41421356 1.73205081 2.        ]]\n",
            "\n",
            " [[ 2.71828183  7.3890561  20.08553692 54.59815003]]\n",
            "\n",
            " [[ 0.84147098  0.90929743  0.14112001 -0.7568025 ]]\n",
            "\n",
            " [[ 0.54030231 -0.41614684 -0.9899925  -0.65364362]]\n",
            "\n",
            " [[0.         0.69314718 1.09861229 1.38629436]]\n",
            "\n",
            " 10\n",
            "\n",
            " 1.118033988749895\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#2-D array\n",
        "# note:- axis = 0 => row and axis = 1 => column\n",
        "a = n.array([\n",
        "            (1,2,3),(4,5,6),(7,8,9)\n",
        "            ])\n",
        "print(a)\n",
        "#column sum\n",
        "sum = a.sum(axis=1)\n",
        "print(\"\\n\",sum)\n",
        "\n",
        "#row sum\n",
        "sum = a.sum(axis=0)\n",
        "print(\"\\n\",sum)\n",
        "\n",
        "\n",
        "#maximum\n",
        "max = a.max()\n",
        "print(max)\n",
        "argmax = a.argmax()\n",
        "print(argmax)\n",
        "\n",
        "#minimum\n",
        "min = a.min()\n",
        "print(min)\n",
        "argmin = a.argmin()\n",
        "print(argmin)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vKA3cH7JJ35Z",
        "outputId": "16485d5b-ef9d-41da-df06-1721ea8ae7b5"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            " [ 6 15 24]\n",
            "\n",
            " [12 15 18]\n",
            "9\n",
            "8\n",
            "1\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Stacking\n",
        "\n",
        "a = n.array([(1,2,3,4)])\n",
        "b = n.array([(5,6,7,8)])\n",
        "\n",
        "#horizontal stack\n",
        "c= n.hstack((a,b))\n",
        "print(c)\n",
        "\n",
        "#vertical stack\n",
        "d = n.vstack((a,b))\n",
        "print(\"\\n\",d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yJOOP4ChLUYh",
        "outputId": "dd8fe514-9f93-4046-ebf5-027bee8664db"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3 4 5 6 7 8]]\n",
            "\n",
            " [[1 2 3 4]\n",
            " [5 6 7 8]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#inseertion of a row or column in an existing 2D  array\n",
        "#syntax => insert(name,position,[elements],axis = 0 or 1)\n",
        "#if axis = 0 => row and if 1 => column\n",
        "a = n.array([\n",
        "            (1,2,3),(4,5,6),(7,8,9)\n",
        "            ])\n",
        "print(a)\n",
        "\n",
        "#row insertion\n",
        "a = n.insert(a,1,[0,1,0],axis = 0)\n",
        "print(\"\\n\",a)\n",
        "\n",
        "\n",
        "# row deletion\n",
        "a = n.delete(a,1,axis=0)\n",
        "print(\"\\n\",a)\n",
        "\n",
        "#column insertion\n",
        "a = n.insert(a,1,[0,1,0],axis = 1)\n",
        "print(\"\\n\",a)\n",
        "\n",
        "#column deletion\n",
        "a = n.delete(a,1,axis=1)\n",
        "print(\"\\n\",a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ix_Q8E55MEcp",
        "outputId": "a1164254-2733-45b8-c015-4728fccfc993"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            " [[1 2 3]\n",
            " [0 1 0]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            " [[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            " [[1 0 2 3]\n",
            " [4 1 5 6]\n",
            " [7 0 8 9]]\n",
            "\n",
            " [[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Matrices in NumPy\n",
        "#Note:- Matrix is strictly 2D\n",
        "\n",
        "mat1 = n.matrix('1,2; 3,4')\n",
        "mat2 = n.matrix('5,6; 7,8')\n",
        "print(mat1)\n",
        "print(\"\\n\",mat2)\n",
        "print(\"\\n\",mat1.shape)\n",
        "\n",
        "#Arithmetic operations\n",
        "print(mat1+mat2)\n",
        "print(\"\\n\",mat1-mat2)\n",
        "print(\"\\n\",mat1*mat2)\n",
        "print(\"\\n\",mat1/mat2)\n",
        "print(\"\\n\",n.divide(mat1,mat2)) #this also works\n",
        "\n",
        "#Transpose\n",
        "print(\"\\n\",n.transpose(mat1))\n",
        "#or\n",
        "print(\"\\n\",mat1.T)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9YIrhWs4OcLQ",
        "outputId": "2bba20cd-3ecc-4d95-91c6-2f2f75bab043"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2]\n",
            " [3 4]]\n",
            "\n",
            " [[5 6]\n",
            " [7 8]]\n",
            "\n",
            " (2, 2)\n",
            "[[ 6  8]\n",
            " [10 12]]\n",
            "\n",
            " [[-4 -4]\n",
            " [-4 -4]]\n",
            "\n",
            " [[19 22]\n",
            " [43 50]]\n",
            "\n",
            " [[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n",
            "\n",
            " [[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n",
            "\n",
            " [[1 3]\n",
            " [2 4]]\n",
            "\n",
            " [[1 3]\n",
            " [2 4]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Insertion of a row or column in an existing matrix\n",
        "\n",
        "#column insertion\n",
        "new_col = n.matrix('5,6')\n",
        "a = n.insert(mat1,2,new_col,axis=1)\n",
        "print(a)\n",
        "\n",
        "#column deletion\n",
        "a = n.delete(a,1,axis=1)\n",
        "print(\"\\n\",a)\n",
        "\n",
        "#row insertion\n",
        "new_row = n.matrix('5,6')\n",
        "a = n.insert(mat1,2,new_row,axis=0)\n",
        "print(\"\\n\",a)\n",
        "\n",
        "# row deletion\n",
        "a = n.delete(a,1,axis=0)\n",
        "print(\"\\n\",a)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4bwMddYiQleg",
        "outputId": "ee6a67bc-8dee-4682-9d82-58c313a41574"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 5]\n",
            " [3 4 6]]\n",
            "\n",
            " [[1 5]\n",
            " [3 6]]\n",
            "\n",
            " [[1 2]\n",
            " [3 4]\n",
            " [5 6]]\n",
            "\n",
            " [[1 2]\n",
            " [5 6]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Linear Algebra with matrices\n",
        "\n",
        "#determinant => .linalg.det() method from numpy is used to find determinant\n",
        "mat1 = n.matrix('1,2; 3,4')\n",
        "print(mat1)\n",
        "\n",
        "det = n.linalg.det(mat1)\n",
        "print(det)\n",
        "\n",
        "#Rank => linalg.matrix_rank() method is used to find rank of a matrix\n",
        "rank = n.linalg.matrix_rank(mat1)\n",
        "print(rank)\n",
        "\n",
        "#inverse => linalg.inv() method is used to find the inverse of a matrix\n",
        "inv = n.linalg.inv(mat1)\n",
        "print(inv)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WOQXCPaYRwOA",
        "outputId": "63751378-3360-4f81-9fd5-aa89d415f122"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2]\n",
            " [3 4]]\n",
            "-2.0000000000000004\n",
            "2\n",
            "[[-2.   1. ]\n",
            " [ 1.5 -0.5]]\n"
          ]
        }
      ]
    }
  ]
}