NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50c0dbaf",
   "metadata": {},
   "source": [
    "# NumPy Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ae42005",
   "metadata": {},
   "source": [
    "- It is python library\n",
    "- It used for working with single and multidimensional array.\n",
    "- NumPy stands For Numerical Python\n",
    "- It is created by Travis Oliphant in 2005.\n",
    "- It is partially written in Python but mostly written in C."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a8c34c7",
   "metadata": {},
   "source": [
    "# Why we use NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bd6511d",
   "metadata": {},
   "source": [
    "- In python we have list which serve purpose of array but they are slow process.\n",
    "- Numpy aims to 50x times faster than python list.\n",
    "- In python list we have to look for each element at different memory place but Array always store at continuous place in memory.\n",
    "- NumPy mostly usefull in Data science\n",
    "- It provides a high-performance multidimensional array object, and tools for working with these arrays. \n",
    "- It is the fundamental package for scientific computing with Python. \n",
    "- It is open-source software."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18638b8a",
   "metadata": {},
   "source": [
    "# Installing Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f03a13f",
   "metadata": {},
   "source": [
    "We have to use following snippet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "520e845c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: numpy in c:\\users\\dell\\anaconda3\\lib\\site-packages (1.21.5)Requirement already satisfied: numpy in c:\\users\\dell\\anaconda3\\lib\\site-packages (1.21.5)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!pip install numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79cf2b26",
   "metadata": {},
   "source": [
    "- To use Numpy we have always import it as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ed139e8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d297951d",
   "metadata": {},
   "source": [
    "- NumPy is usually imported under the np alias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0ff3a375",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5de8363",
   "metadata": {},
   "source": [
    "# Creating Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f7f4013",
   "metadata": {},
   "source": [
    "- The array object in NumPy is called ndarray.\n",
    "\n",
    "- We can create a NumPy ndarray object by using the array() function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "925b5f03",
   "metadata": {},
   "source": [
    "* To create an ndarray, we can pass a list, tuple or any array-like object into the array() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c7def0c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4  5  3  7  8 10]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# here a is our python list\n",
    "a = [4, 5, 3, 7, 8, 10]\n",
    "\n",
    "# a1 become array from the given list\n",
    "arr  = np.array(a)\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d443a4a3",
   "metadata": {},
   "source": [
    "* Use a tuple to create a NumPy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "29b4e3ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "tup = (1, 2, 3, 4, 5)\n",
    "arr = np.array(tup)\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b5352e30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8a26afc",
   "metadata": {},
   "source": [
    "# Basic array characteristics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad789892",
   "metadata": {},
   "source": [
    "It includes \n",
    "1. type\n",
    "2. dimension of array\n",
    "3. shape of array\n",
    "4. size of array\n",
    "5. types of element"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ddea218",
   "metadata": {},
   "source": [
    "# 1. type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2612a159",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array is of type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    " \n",
    "# Creating array object\n",
    "arr = np.array( [[ 1, 2, 3],\n",
    "                 [ 4, 2, 5]] )\n",
    " \n",
    "# Printing type of arr object\n",
    "print(\"Array is of type: \", type(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd82f38",
   "metadata": {},
   "source": [
    "# 2. dimension of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "3fa06bfe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No. of dimensions of arr:  1\n",
      "No. of dimensions of arr1:  2\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# Creating array object\n",
    "arr = np.array([ 1, 2, 3])\n",
    "\n",
    "arr1 = np.array( [[ 1, 2, 3], \n",
    "                 [ 4, 2, 5]] )\n",
    "\n",
    "# Printing array dimensions (axes)\n",
    "print(\"No. of dimensions of arr: \", arr.ndim)\n",
    "print(\"No. of dimensions of arr1: \", arr1.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c60eba2",
   "metadata": {},
   "source": [
    "# 3. shape of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "b97a25bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of array:  (3,)\n",
      "Shape of array1:  (2, 3)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([ 1, 2, 3])\n",
    "\n",
    "arr1 = np.array( [[ 1, 2, 3], \n",
    "                 [ 4, 2, 5]] )\n",
    "# Printing shape of array\n",
    "print(\"Shape of array: \", arr.shape)\n",
    "print(\"Shape of array1: \", arr1.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9440df20",
   "metadata": {},
   "source": [
    "# 4. size of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c6408d36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of array:  3\n",
      "Size of array1:  6\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([ 1, 2, 3])\n",
    "\n",
    "arr1 = np.array( [[ 1, 2, 3], \n",
    "                 [ 4, 2, 5]] )\n",
    "# Printing size (total number of elements) of array\n",
    "print(\"Size of array: \", arr.size)\n",
    "print(\"Size of array1: \", arr1.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e1aef81",
   "metadata": {},
   "source": [
    "# 5. types of element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a182f1c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array stores elements of type:  int32\n",
      "Array1 stores elements of type:  int32\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([ 1, 2, 3])\n",
    "\n",
    "arr1 = np.array( [[ 1, 2, 3], \n",
    "                 [ 4, 2, 5]] )\n",
    "\n",
    "# Printing type of elements in array\n",
    "print(\"Array stores elements of type: \", arr.dtype)\n",
    "print(\"Array1 stores elements of type: \", arr1.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "405c9b75",
   "metadata": {},
   "source": [
    "* desired data type of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "ce2ab3d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data type of given array is :  [1 2 3]\n",
      "Data type of given array is:  [[1.+0.j 2.+0.j 3.+0.j]\n",
      " [4.+0.j 2.+0.j 5.+0.j]]\n",
      "Data type of given array is:  [1. 2. 3.]\n",
      "Data type of given array is:  [ True  True False]\n"
     ]
    }
   ],
   "source": [
    "# dtype parameter \n",
    "import numpy as np \n",
    "arr = np.array([1, 2, 3], dtype = int) \n",
    "print(\"Data type of given array is : \", arr)\n",
    "\n",
    "arr1 = np.array( [[ 1, 2, 3], \n",
    "                 [ 4, 2, 5]], dtype = complex )\n",
    "print(\"Data type of given array is: \", arr1)\n",
    "\n",
    "arr2 = np.array([1, 2, 3], dtype = float) \n",
    "print(\"Data type of given array is: \", arr2)\n",
    "\n",
    "arr3 = np.array([1, 2, 0], dtype = bool) \n",
    "print(\"Data type of given array is: \", arr3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d713e8fd",
   "metadata": {},
   "source": [
    "# Higher Dimensional Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c37256d2",
   "metadata": {},
   "source": [
    "* When the array is created, you can define the number of dimensions by using the ndmin argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3d10c12b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array is :  [[[[[1 2 3 4]]]]]\n",
      "number of dimensions : 5\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# Create an array with 5 dimensions and verify that it has 5 dimensions\n",
    "arr = np.array([1, 2, 3, 4], ndmin=5)\n",
    "\n",
    "print(\"Array is : \", arr)\n",
    "print('number of dimensions :', arr.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7281924d",
   "metadata": {},
   "source": [
    "# NumPy Array Reshaping"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcdebcc3",
   "metadata": {},
   "source": [
    "- Reshaping means changing the shape of an array.\n",
    "\n",
    "- The shape of an array is the number of elements in each dimension.\n",
    "\n",
    "- By reshaping we can add or remove dimensions or change number of elements in each dimension.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2e81407",
   "metadata": {},
   "source": [
    "1. Reshape From 1-D to 2-D\n",
    "2. Reshape From 1-D to 3-D\n",
    "3. Flattening the arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8de7737",
   "metadata": {},
   "source": [
    "# 1. Reshape From 1-D to 2-D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bec1fc6c",
   "metadata": {},
   "source": [
    "- Convert the following 1-D array with 10 elements into a 2-D array.\n",
    "\n",
    "- The outermost dimension will have 4 arrays, each with 3 elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "36926e78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 2 dimensional array is : \n",
      " [[ 1  2  3  4  5  6  7  8  9 10]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n",
    "\n",
    "newarr = arr.reshape(1, 10)\n",
    "\n",
    "print(\"The 2 dimensional array is : \\n\", newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71e1b5f0",
   "metadata": {},
   "source": [
    "We can also shape it according to column : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "44725f2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 2 dimensional array is : \n",
      " [[ 1  2]\n",
      " [ 3  4]\n",
      " [ 5  6]\n",
      " [ 7  8]\n",
      " [ 9 10]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n",
    "\n",
    "newarr = arr.reshape(5, 2, order = 'C')\n",
    "\n",
    "print(\"The 2 dimensional array is : \\n\", newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d1ad440",
   "metadata": {},
   "source": [
    "# 2. Reshape From 1-D to 3-D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c586bd2d",
   "metadata": {},
   "source": [
    "* Convert the following 1-D array with 12 elements into a 3-D array.\n",
    "\n",
    "* The outermost dimension will have 2 arrays that contains 3 arrays, each with 2 elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "e919a163",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 3D array is : \n",
      " [[[ 1  2]\n",
      "  [ 3  4]\n",
      "  [ 5  6]]\n",
      "\n",
      " [[ 7  8]\n",
      "  [ 9 10]\n",
      "  [11 12]]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])\n",
    "\n",
    "newarr = arr.reshape(2, 3, 2)\n",
    "\n",
    "print(\"The 3D array is : \\n\", newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54d0c602",
   "metadata": {},
   "source": [
    "# 3. Flattening the arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5bbd477",
   "metadata": {},
   "source": [
    "- Flattening array means converting a multidimensional array into a 1D array.\n",
    "- We can use reshape(-1) to do this.\n",
    "- we can use ravel() method also"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "52822070",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original array is : \n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "\n",
      "Array after flattening is : \n",
      " [ 1  2  3  4  5  6  7  8  9 10 11 12]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
    "\n",
    "print(\"The original array is : \\n\", arr)\n",
    "\n",
    "newarr = arr.reshape(-1)\n",
    "\n",
    "print(\"\\nArray after flattening is : \\n\", newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "7443ac53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original array is : \n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "\n",
      "Flatten array is :  [ 1  2  3  4  5  6  7  8  9 10 11 12]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
    "\n",
    "print(\"The original array is : \\n\", arr)\n",
    "\n",
    "flatten_array = arr.ravel()\n",
    "print(\"\\nFlatten array is : \", flatten_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99e9e35d",
   "metadata": {},
   "source": [
    "- WE can pass order parameter for flattening array, bydefault it is order by rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "4990dc57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original array is : \n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "\n",
      "Flatten array is :  [ 1  5  9  2  6 10  3  7 11  4  8 12]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
    "\n",
    "print(\"The original array is : \\n\", arr)\n",
    "\n",
    "flatten_array = arr.ravel(order = 'F')\n",
    "print(\"\\nFlatten array is : \", flatten_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e83af455",
   "metadata": {},
   "source": [
    "# * Array Creation Routines"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e448ba49",
   "metadata": {},
   "source": [
    "It includes following parameter to create array\n",
    "1. empty\n",
    "2. ones\n",
    "3. zeros\n",
    "4. arrange\n",
    "6. linspace"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e256b87d",
   "metadata": {},
   "source": [
    "# 1. numpy.empty()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8b7e691",
   "metadata": {},
   "source": [
    "- It creates an uninitialized array of specified shape and dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f2aa04a",
   "metadata": {},
   "source": [
    "- numpy.empty(shape, dtype = float, order = 'C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "0246992a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[          0           0]\n",
      " [-1510285232       32767]\n",
      " [          1           0]\n",
      " [         -1          -1]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "x = np.empty([4, 2], dtype = int) \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "cbda8f03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8.59247481e-312 5.68175493e-322 0.00000000e+000]\n",
      " [0.00000000e+000             nan 1.16095484e-028]\n",
      " [8.44747281e+252 7.23796664e+159 1.28311626e+272]\n",
      " [9.34634029e+218 1.05223146e-153 6.32300944e+233]\n",
      " [2.20892684e+161 1.14115712e+243 9.38011961e-154]\n",
      " [8.29655075e-114 8.93168689e+271 4.98131536e+151]\n",
      " [1.94920670e-153 1.23971686e+224 2.59819219e-306]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "x = np.empty([7, 3], dtype = float, order = 'C') \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb69b217",
   "metadata": {},
   "source": [
    "# 2. numpy.ones()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2604b484",
   "metadata": {},
   "source": [
    "- Returns a new array of specified size, filled with ones."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "419fc34e",
   "metadata": {},
   "source": [
    "- numpy.ones(shape, dtype = float, order = 'C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "e917b306",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "# array of five ones. Default dtype is float \n",
    "import numpy as np \n",
    "arr = np.ones(5) \n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "78c2b74a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1]\n",
      " [1 1 1]\n",
      " [1 1 1]]\n"
     ]
    }
   ],
   "source": [
    "# array of 3 X 3 of datatype integer\n",
    "import numpy as np \n",
    "arr = np.ones([3,3], dtype = int) \n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94e0910f",
   "metadata": {},
   "source": [
    "# 3. numpy.zeros()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "815a8cf9",
   "metadata": {},
   "source": [
    "- Returns a new array of specified size, filled with zeros."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bb8d476",
   "metadata": {},
   "source": [
    "- numpy.zeros(shape, dtype = float, order = 'C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "79bd436c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "# singe dimension array of five zeros. Default dtype is float \n",
    "import numpy as np \n",
    "arr = np.zeros(5) \n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "f0a2852b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0]\n",
      " [0 0 0]\n",
      " [0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "# array of 3 X 3 of datatype integer\n",
    "import numpy as np \n",
    "arr = np.zeros((3, 3), dtype = int)  \n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "250fcfbc",
   "metadata": {},
   "source": [
    "# 4. numpy.arrange()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4bc0690",
   "metadata": {},
   "source": [
    "- This function returns an ndarray object containing evenly spaced values within a given range."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc1d38e3",
   "metadata": {},
   "source": [
    "- format - numpy.arange(start, stop, step, dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33d69a86",
   "metadata": {},
   "source": [
    "- It always give single dimension array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "960f9179",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A sequential array is : [0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# create array with 5 elements\n",
    "import numpy as np \n",
    "arr = np.arange(5) \n",
    "print(\"\\nA sequential array is :\", arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "2779d730",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A sequential array with steps of 2:\n",
      " [10 12 14 16 18 20 22 24 26 28]\n"
     ]
    }
   ],
   "source": [
    "# start and stop parameters set \n",
    "import numpy as np \n",
    "#Create a sequence of integers from 10 to 30 with steps of 2\n",
    "arr = np.arange(10,30,2) \n",
    "print(\"\\nA sequential array with steps of 2:\\n\", arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd1e7fd3",
   "metadata": {},
   "source": [
    "# 5. numpy.linspace()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3f35c3d",
   "metadata": {},
   "source": [
    "- This function is similar to arange() function. In this function, instead of step size, the number of evenly spaced values between the interval is specified."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df6f6467",
   "metadata": {},
   "source": [
    "- numpy.linspace(start, stop, num, endpoint, retstep, dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "25c13c84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A sequential array with 10 values between 5 and 15 :\n",
      " [ 5.          6.11111111  7.22222222  8.33333333  9.44444444 10.55555556\n",
      " 11.66666667 12.77777778 13.88888889 15.        ]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "\n",
    "#prints 10 values which are evenly spaced over the given interval 5-15\n",
    "arr = np.linspace(5,15,10)\n",
    "\n",
    "print(\"\\nA sequential array with 10 values between 5 and 15 :\\n\", arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4166ed51",
   "metadata": {},
   "source": [
    "- endpoint = True by default, hence the stop value is included in the sequence. If false, it is not included"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "d921a825",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A sequential array with 5 values between 10 and 20 :\n",
      " [10. 12. 14. 16. 18.]\n"
     ]
    }
   ],
   "source": [
    "# endpoint set to false \n",
    "import numpy as np \n",
    "arr = np.linspace(10,20, 5, endpoint = False) \n",
    "print(\"\\nA sequential array with 5 values between 10 and 20 :\\n\",arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a465e53",
   "metadata": {},
   "source": [
    "# * NumPy Random"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "610c86f7",
   "metadata": {},
   "source": [
    "It includes following methods\n",
    "1. random()\n",
    "2. randint()\n",
    "3. rand()\n",
    "4. choice()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7ffd947",
   "metadata": {},
   "source": [
    "# 1.random()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67c98b97",
   "metadata": {},
   "source": [
    "- Create an array with random values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "e08506ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A random array:\n",
      " [[0.69767357 0.55458978]\n",
      " [0.70458591 0.65287982]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random((2, 2))\n",
    "print (\"\\nA random array:\\n\", arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "42468ab0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A random array:\n",
      " [[0.00858437 0.55984189 0.74582852 0.40748759 0.20504533]\n",
      " [0.43967176 0.44266411 0.15891589 0.87257821 0.13961442]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.random((2, 5))\n",
    "print (\"\\nA random array:\\n\", arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0b7144",
   "metadata": {},
   "source": [
    "# 2. randint()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01b72186",
   "metadata": {},
   "source": [
    "- The randint() method takes a size parameter where you can specify the shape of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "568f1e9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The 1-D random array is : \n",
      " [42 38 57 37 95]\n"
     ]
    }
   ],
   "source": [
    "#Generate a 1-D array containing 5 random integers from 0 to 100:\n",
    "import numpy as np\n",
    "\n",
    "arr = np.random.randint(100, size=(5))\n",
    "\n",
    "print(\"\\nThe 1-D random array is : \\n\",arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "984127d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The random array is : \n",
      " [[15  5 31 22  2 66 75 16  0 62]\n",
      " [ 1 37 10 99 82 99 88 62 92 96]\n",
      " [90 26 22 89 15 31 95 14 42 18]\n",
      " [84 89 56  7 87 61 41 85 84 56]\n",
      " [61 64 32 50 62 37 56 90 59 81]\n",
      " [18 74 98 57 85 18 86 37 59 55]\n",
      " [33 41 91 54 99 38 98 48 80 54]\n",
      " [13 99 23 95 13 64 97 20 36 70]\n",
      " [76 98  3 34 71  1 92 47  2 70]\n",
      " [45 51 15 75 42 78  5 16 95  5]]\n"
     ]
    }
   ],
   "source": [
    "#Generate a 1-D array containing 5 random integers from 0 to 100:\n",
    "import numpy as np\n",
    "\n",
    "arr = np.random.randint(100, size=(10,10))\n",
    "\n",
    "print(\"\\nThe random array is : \\n\",arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec2a8683",
   "metadata": {},
   "source": [
    "# 3. rand()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7749b720",
   "metadata": {},
   "source": [
    "- The rand() method also allows you to specify the shape of the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "42679a47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Random number array is : \n",
      " [0.37779077 0.73272848 0.12946597 0.37765703 0.24569147]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating random array with default datatype float\n",
    "arr = np.random.rand(5)\n",
    "\n",
    "print(\"\\nRandom number array is : \\n\", arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a58c90",
   "metadata": {},
   "source": [
    "- Generate a 2-D array with 3 rows, each row containing 5 random numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "8f570755",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Random 2-D array is : \n",
      " [[0.77881226 0.90328898 0.11899552 0.07109912 0.32139356]\n",
      " [0.75073146 0.09951671 0.18873064 0.91210232 0.30602568]\n",
      " [0.09383484 0.52941406 0.04598477 0.22979217 0.3746314 ]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating random array with default datatype float\n",
    "arr = np.random.rand(3, 5)\n",
    "\n",
    "print(\"\\nRandom 2-D array is : \\n\", arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ad51be3",
   "metadata": {},
   "source": [
    "# 4. choice()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03febed5",
   "metadata": {},
   "source": [
    "- The choice() method allows you to generate a random value based on an array of values.\n",
    "\n",
    "- The choice() method takes an array as a parameter and randomly returns one of the values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "5e7d524f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Random number is :  9\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# It will return only one random number\n",
    "x = np.random.choice([3, 5, 7, 9])\n",
    "\n",
    "print(\"\\nRandom number is : \", x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "f84cdc8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Random number array is : \n",
      " [0.27632695 0.26717078 0.5905044  0.72809446 0.21938548]\n",
      "\n",
      "Random number is :  0.21938547889611582\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating random array with default datatype float\n",
    "arr = np.random.rand(5)\n",
    "\n",
    "print(\"\\nRandom number array is : \\n\", arr)\n",
    "\n",
    "x = np.random.choice(arr)\n",
    "\n",
    "print(\"\\nRandom number is : \", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f8df578",
   "metadata": {},
   "source": [
    "- Generate a 2-D array that consists of the values in the array parameter (3, 5, 7, and 9):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "39396e14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Random array is : \n",
      "  [0.81148917 0.18086692 0.536034   0.65842367 0.68262588]\n",
      "\n",
      "Array of size 3X5 is : \n",
      " [[0.65842367 0.65842367 0.18086692 0.68262588 0.536034  ]\n",
      " [0.536034   0.65842367 0.536034   0.81148917 0.18086692]\n",
      " [0.68262588 0.536034   0.18086692 0.536034   0.536034  ]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating random array with default datatype float\n",
    "arr = np.random.rand(5)\n",
    "\n",
    "print(\"\\nRandom array is : \\n \", arr)\n",
    "\n",
    "x = np.random.choice(arr, size=(3, 5))\n",
    "\n",
    "print(\"\\nArray of size 3X5 is : \\n\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb688602",
   "metadata": {},
   "source": [
    "# * Random Permutations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "068956bb",
   "metadata": {},
   "source": [
    "- A permutation refers to an arrangement of elements."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14d275a5",
   "metadata": {},
   "source": [
    "It includes two methods\n",
    "1. shuffle()\n",
    "2. permutation()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ac226d9",
   "metadata": {},
   "source": [
    "# 1. shuffle()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9428fd75",
   "metadata": {},
   "source": [
    "- The shuffle() method makes changes to the original array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "45dbd64e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Original array is : \n",
      " [1 2 3 4 5]\n",
      "\n",
      "Array after shuffling : \n",
      " [1 5 4 3 2]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "#Creating array\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print(\"\\nOriginal array is : \\n\", arr)\n",
    "\n",
    "shfl = np.random.shuffle(arr)\n",
    "\n",
    "print(\"\\nArray after shuffling : \\n\", arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6edc113",
   "metadata": {},
   "source": [
    "# 2. permutation()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d4f514f",
   "metadata": {},
   "source": [
    "- The permutation() method returns a re-arranged array (and leaves the original array un-changed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d9eb5fcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Original array is : \n",
      " [1 2 3 4 5]\n",
      "\n",
      "Array after permutation : \n",
      " [1 3 5 2 4]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "#Creating array\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print(\"\\nOriginal array is : \\n\", arr)\n",
    "\n",
    "p = np.random.permutation(arr)\n",
    "print(\"\\nArray after permutation : \\n\", p)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b6dfdce",
   "metadata": {},
   "source": [
    "# * NumPy - Arithmetic Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a7d5f71",
   "metadata": {},
   "source": [
    "It includes following methods\n",
    "1. add\n",
    "2. substract\n",
    "3. multiply\n",
    "4. divide\n",
    "5. transpose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6c5e44c",
   "metadata": {},
   "source": [
    "# Program for all above methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba820dc3",
   "metadata": {},
   "source": [
    "- Dimension of both array must be same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "ea0b03e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Our first array is : \n",
      " [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "\n",
      "Our second array is : \n",
      " [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "\n",
      "Addition of two array is : \n",
      " [[ 2  4  6]\n",
      " [ 8 10 12]\n",
      " [14 16 18]]\n",
      "\n",
      "Subtraction  of two array is : \n",
      " [[0 0 0]\n",
      " [0 0 0]\n",
      " [0 0 0]]\n",
      "\n",
      "Multiplication  of two array is : \n",
      " [[ 1  4  9]\n",
      " [16 25 36]\n",
      " [49 64 81]]\n",
      "\n",
      "Division of two array is : \n",
      " [[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "\n",
      "Original array is :\n",
      " [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "\n",
      "Transpose of the array is : \n",
      " [[1 4 7]\n",
      " [2 5 8]\n",
      " [3 6 9]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "#Creating two arrays to perform operation in it.\n",
    "#first array \n",
    "array1 = np.arange(1, 10).reshape(3,3)\n",
    "\n",
    "print(\"\\nOur first array is : \\n\", array1)\n",
    "\n",
    "#second array\n",
    "array2 = np.arange(1, 10).reshape(3,3)\n",
    "\n",
    "print(\"\\nOur second array is : \\n\", array2)\n",
    "\n",
    "#addition of two array using add() method\n",
    "\n",
    "addition = np.add(array1, array2)\n",
    "print(\"\\nAddition of two array is : \\n\", addition)\n",
    "\n",
    "#subtraction of two array using substract() method\n",
    "\n",
    "subtraction  = np.subtract(array1, array2)\n",
    "print(\"\\nSubtraction  of two array is : \\n\", subtraction )\n",
    "\n",
    "#multiplication of two array using multiply() method\n",
    "\n",
    "multiplication  = np.multiply(array1, array2)\n",
    "print(\"\\nMultiplication  of two array is : \\n\", multiplication )\n",
    "\n",
    "#division of two array using divide() method\n",
    "\n",
    "division  = np.divide(array1, array2)\n",
    "print(\"\\nDivision of two array is : \\n\", division )\n",
    "\n",
    "#transpose of given array is\n",
    "#transpose of 1st array\n",
    "print(\"\\nOriginal array is :\\n\", array1)\n",
    "\n",
    "t = array1.transpose()\n",
    "print(\"\\nTranspose of the array is : \\n\", t)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dbab867",
   "metadata": {},
   "source": [
    "# * Unary operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05b701e0",
   "metadata": {},
   "source": [
    "It includes following functions\n",
    "\n",
    "1.min()\n",
    "\n",
    "2.max()\n",
    "\n",
    "3.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "a1b81d1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The given array is : \n",
      " [[1 5 6]\n",
      " [4 7 2]\n",
      " [3 1 9]]\n",
      "\n",
      "Largest element is: 9\n",
      "\n",
      "Row-wise maximum elements: [6 7 9]\n",
      "\n",
      "Column-wise minimum elements: [1 1 2]\n",
      "\n",
      "Sum of all array elements: 38\n",
      "\n",
      "Sum of all array elements: [ 8 13 17]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    " \n",
    "arr = np.array([[1, 5, 6], [4, 7, 2],[3, 1, 9]])\n",
    "print(\"\\nThe given array is : \\n\", arr)\n",
    "\n",
    "# to find maximum element of array\n",
    "large = arr.max()\n",
    "print (\"\\nLargest element is:\", large)\n",
    "\n",
    "#to print row wise maximum element we have to use parameter axis\n",
    "row_large = arr.max(axis = 1)\n",
    "print (\"\\nRow-wise maximum elements:\", row_large)\n",
    " \n",
    "# To find minimum element of array\n",
    "small = arr.min(axis = 0)\n",
    "print (\"\\nColumn-wise minimum elements:\", small)\n",
    " \n",
    "# To find sum of array elements\n",
    "sum_array = arr.sum()\n",
    "print (\"\\nSum of all array elements:\", sum_array)\n",
    "\n",
    "#axis wise sum\n",
    "sum_array = arr.sum(axis = 0)\n",
    "print (\"\\nSum of all array elements:\", sum_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6abbe30",
   "metadata": {},
   "source": [
    "# * NumPy - Statistical Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc03ebd6",
   "metadata": {},
   "source": [
    "It includes \n",
    "1. median()\n",
    "2. mean()\n",
    "3. average()\n",
    "4. Standard Deviation/std()\n",
    "5. Variance/var()\n",
    "6. square root/ sqrt()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dfabc27",
   "metadata": {},
   "source": [
    "# 1. median()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2e00788",
   "metadata": {},
   "source": [
    "- Median is defined as the value separating the higher half of a data sample from the lower half."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "5d56de25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Our array is:\n",
      " [[30 65 70]\n",
      " [80 95 10]\n",
      " [50 90 60]]\n",
      "\n",
      "Median of an array is: \n",
      " 65.0\n",
      "\n",
      "Median along axis = 0 is : \n",
      " [50. 90. 60.]\n",
      "\n",
      "Median along axis = 1 is : \n",
      " [65. 80. 60.]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "# creating array\n",
    "a = np.array([[30,65,70],[80,95,10],[50,90,60]]) \n",
    "\n",
    "print(\"\\nOur array is:\\n\", a)  \n",
    "\n",
    "# calculate the median of array\n",
    "med = np.median(a)\n",
    "print(\"\\nMedian of an array is: \\n\" , med)\n",
    "\n",
    "#Applying median() function along axis 0 (column wise)\n",
    "med1 = np.median(a, axis = 0) \n",
    "print(\"\\nMedian along axis = 0 is : \\n\", med1) \n",
    " \n",
    "#Applying median() function along axis 1 (row wise)\n",
    "med2 = np.median(a, axis = 1)\n",
    "print(\"\\nMedian along axis = 1 is : \\n\", med2) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc1790e4",
   "metadata": {},
   "source": [
    "# 2. mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "025fc9f0",
   "metadata": {},
   "source": [
    "- Arithmetic mean is the sum of elements along an axis divided by the number of elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "a7b609a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Our array is:\n",
      " [[30 65 70]\n",
      " [80 95 10]\n",
      " [50 90 60]]\n",
      "\n",
      "Mean of an array is: \n",
      " 61.111111111111114\n",
      "\n",
      "Mean along axis = 0 is : \n",
      " [53.33333333 83.33333333 46.66666667]\n",
      "\n",
      "Mean along axis = 1 is : \n",
      " [55.         61.66666667 66.66666667]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "# creating array\n",
    "a = np.array([[30,65,70],[80,95,10],[50,90,60]]) \n",
    "\n",
    "print(\"\\nOur array is:\\n\", a)  \n",
    "\n",
    "# calculate the mean of array\n",
    "m = np.mean(a)\n",
    "print(\"\\nMean of an array is: \\n\" , m)\n",
    "\n",
    "#Applying mean() function along axis 0 (row wise)\n",
    "m1 = np.mean(a, axis = 0) \n",
    "print(\"\\nMean along axis = 0 is : \\n\", m1) \n",
    " \n",
    "#Applying mean() function along axis 1 (column wise)\n",
    "m2 = np.mean(a, axis = 1)\n",
    "print(\"\\nMean along axis = 1 is : \\n\", m2) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18fafe3d",
   "metadata": {},
   "source": [
    "# 3. average()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "799c4e27",
   "metadata": {},
   "source": [
    "- Weighted average is an average resulting from the multiplication of each component by a factor reflecting its importance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "f3d4b778",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Our array is: \n",
      " [1 2 3 4]\n",
      "\n",
      "Average of given array is  :  2.5\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "# creating array\n",
    "a = np.array([1,2,3,4]) \n",
    "\n",
    "print(\"\\nOur array is: \\n\", a)\n",
    "\n",
    "#Applying average() function\n",
    "\n",
    "avg = np.average(a) \n",
    "print(\"\\nAverage of given array is  : \", avg)  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1de4f75",
   "metadata": {},
   "source": [
    "# 4. Standard Deviation/std()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b13a3247",
   "metadata": {},
   "source": [
    "- Standard deviation is the square root of the average of squared deviations from mean"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcc6f5c5",
   "metadata": {},
   "source": [
    "* std = sqrt(mean(abs(x - x.mean())**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "215d5658",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Our array is: \n",
      " [1 2 3 4]\n",
      "\n",
      "Deviation of given array is  :  1.118033988749895\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "# creating array\n",
    "a = np.array([1,2,3,4]) \n",
    "\n",
    "print(\"\\nOur array is: \\n\", a)\n",
    "\n",
    "#Applying std() function\n",
    "\n",
    "deviation = np.std(a) \n",
    "print(\"\\nDeviation of given array is  : \", deviation) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a47d4244",
   "metadata": {},
   "source": [
    "# 5. Variance/var()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c57b56a6",
   "metadata": {},
   "source": [
    "- Variance is the average of squared deviations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "894f4355",
   "metadata": {},
   "source": [
    "- mean(abs(x - x.mean())**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "b1ed5cf7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Our array is: \n",
      " [1 2 3 4]\n",
      "\n",
      "Variation of given array is  :  1.25\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "# creating array\n",
    "a = np.array([1,2,3,4]) \n",
    "\n",
    "print(\"\\nOur array is: \\n\", a)\n",
    "\n",
    "#Applying var() function\n",
    "\n",
    "variation = np.var(a) \n",
    "print(\"\\nVariation of given array is  : \", variation) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aef8f3f8",
   "metadata": {},
   "source": [
    "# 6. square root/ sqrt()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d87114fb",
   "metadata": {},
   "source": [
    "- It return square root of array element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "99a87017",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Our array is: \n",
      " [16  5  7]\n",
      "\n",
      "Square roo of given array is  : \n",
      " [4.         2.23606798 2.64575131]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "# creating array\n",
    "a = np.array([16, 5, 7]) \n",
    "\n",
    "print(\"\\nOur array is: \\n\", a)\n",
    "\n",
    "#Applying sqrt() function\n",
    "sqrt_no = np.sqrt(a) \n",
    "print(\"\\nSquare roo of given array is  : \\n\", sqrt_no) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf705217",
   "metadata": {},
   "source": [
    "# * NumPy - Indexing & Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "754451a0",
   "metadata": {},
   "source": [
    "# 1. Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7076d70a",
   "metadata": {},
   "source": [
    "- Array indexing is the same as accessing an array element.\n",
    "- You can access an array element by referring to its index number.\n",
    "\n",
    "- The indexes in NumPy arrays start with 0, meaning that the first element has index 0, and the second has index 1 etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "aa8b1cab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "First element of array is :  1\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating array\n",
    "arr = np.array([1, 2, 3, 4])\n",
    "#getting first element of array\n",
    "print(\"\\nFirst element of array is : \", arr[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "b9804794",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Our array is : \n",
      " [[ 1  2  3  4  5]\n",
      " [ 6  7  8  9 10]\n",
      " [11 12 13 14 15]\n",
      " [16 17 18 19 20]\n",
      " [21 22 23 24 25]\n",
      " [26 27 28 29 30]\n",
      " [31 32 33 34 35]\n",
      " [36 37 38 39 40]\n",
      " [41 42 43 44 45]\n",
      " [46 47 48 49 50]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating array of 50 elements\n",
    "a = np.arange(1, 51).reshape(10, 5)\n",
    "print(\"\\nOur array is : \\n\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52b91e5a",
   "metadata": {},
   "source": [
    "- To get complete row for specific index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "e096bdab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element of rows on index 3 is : \n",
      " [16 17 18 19 20]\n"
     ]
    }
   ],
   "source": [
    "print(\"Element of rows on index 3 is : \\n\", a[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f44d75e7",
   "metadata": {},
   "source": [
    "* To get both row and column of specific index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "15611a39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element is : \n",
      " 15\n"
     ]
    }
   ],
   "source": [
    "print(\"Element is : \\n\", a[2, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfe36ddf",
   "metadata": {},
   "source": [
    "# 2. Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d1f7bbd",
   "metadata": {},
   "source": [
    "- Slicing in python means taking elements from one given index to another given index.\n",
    "\n",
    "- We pass slice instead of index like this: [start:end].\n",
    "\n",
    "- We can also define the step, like this: [start:end:step].\n",
    "\n",
    "- If we don't pass start its considered 0\n",
    "\n",
    "- If we don't pass end its considered length of array in that dimension\n",
    "\n",
    "- If we don't pass step its considered 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "a3d51a92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Array after slicing is : \n",
      " [2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "#Creating array of 7 elements\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "\n",
    "#Slice elements from index 1 to index 5\n",
    "print(\"\\nArray after slicing is : \\n\", arr[1:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "090205cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Our array is : \n",
      " [[ 1  2  3  4  5]\n",
      " [ 6  7  8  9 10]\n",
      " [11 12 13 14 15]\n",
      " [16 17 18 19 20]\n",
      " [21 22 23 24 25]\n",
      " [26 27 28 29 30]\n",
      " [31 32 33 34 35]\n",
      " [36 37 38 39 40]\n",
      " [41 42 43 44 45]\n",
      " [46 47 48 49 50]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating array of 50 elements\n",
    "a = np.arange(1, 51).reshape(10, 5)\n",
    "print(\"\\nOur array is : \\n\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9de69fc4",
   "metadata": {},
   "source": [
    "* To get specific element from row and column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "290a19aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Row wise elements are : \n",
      " [[11 12 13 14 15]\n",
      " [16 17 18 19 20]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Row wise elements are : \\n\", a[2:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "308e5050",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Row and column wise elements are : \n",
      " [[12 13]\n",
      " [17 18]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Row and column wise elements are : \\n\", a[2:4, 1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "9f355fb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Column wise elements are : \n",
      " [[ 3  4]\n",
      " [ 8  9]\n",
      " [13 14]\n",
      " [18 19]\n",
      " [23 24]\n",
      " [28 29]\n",
      " [33 34]\n",
      " [38 39]\n",
      " [43 44]\n",
      " [48 49]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Column wise elements are : \\n\", a[:,2:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef4757ef",
   "metadata": {},
   "source": [
    "* Using step in parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "3155ce47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Row and column wise elements are : \n",
      " [[12]\n",
      " [17]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Row and column wise elements are : \\n\", a[2:4, 1:3:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cd66849",
   "metadata": {},
   "source": [
    "# Negative Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e247231",
   "metadata": {},
   "source": [
    "- Slice from the index 3 from the end to index 1 from the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "697a3358",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Original array is :\n",
      " [1 2 3 4 5 6 7]\n",
      "\n",
      "Array after negative slicing : \n",
      " [5 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "print(\"\\nOriginal array is :\\n\", arr)\n",
    "slicing = arr[-3:-1]\n",
    "print(\"\\nArray after negative slicing : \\n\", slicing)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c43dff6",
   "metadata": {},
   "source": [
    "# * NumPy Joining Array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f4f585c",
   "metadata": {},
   "source": [
    "- Joining means putting contents of two or more arrays in a single array."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f76739e",
   "metadata": {},
   "source": [
    "- numpy.concatenate((a1, a2, ...), axis)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "23a76074",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "First array is : \n",
      " [1 2 3]\n",
      "\n",
      "Second array is : \n",
      " [4 5 6]\n",
      "\n",
      "Array after joining is : \n",
      " [1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating first array\n",
    "arr1 = np.array([1, 2, 3])\n",
    "print(\"\\nFirst array is : \\n\", arr1)\n",
    "\n",
    "# creating second array\n",
    "arr2 = np.array([4, 5, 6])\n",
    "print(\"\\nSecond array is : \\n\", arr2)\n",
    "\n",
    "#Joins two array\n",
    "arr = np.concatenate((arr1, arr2))\n",
    "\n",
    "print(\"\\nArray after joining is : \\n\", arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56494dfb",
   "metadata": {},
   "source": [
    "- Joining 2-D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d170e8d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "First array is : \n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]]\n",
      "\n",
      "Second array is : \n",
      " [[17 18 19 20]\n",
      " [21 22 23 24]\n",
      " [25 26 27 28]\n",
      " [29 30 31 32]]\n",
      "\n",
      "Array after column wise joining is : \n",
      " [[ 1  2  3  4 17 18 19 20]\n",
      " [ 5  6  7  8 21 22 23 24]\n",
      " [ 9 10 11 12 25 26 27 28]\n",
      " [13 14 15 16 29 30 31 32]]\n",
      "\n",
      "Array after row wise joining is : \n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]\n",
      " [17 18 19 20]\n",
      " [21 22 23 24]\n",
      " [25 26 27 28]\n",
      " [29 30 31 32]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# Creating two arrays \n",
    "a = np.arange(1,17).reshape(4,4)\n",
    "print(\"\\nFirst array is : \\n\", a)\n",
    "\n",
    "# Creating another array\n",
    "b = np.arange(17,33).reshape(4,4)\n",
    "print(\"\\nSecond array is : \\n\", b)\n",
    "\n",
    "#Joins two array\n",
    "combination1 = np.concatenate((a, b), axis = 1) #column wise\n",
    "\n",
    "combination2 = np.concatenate((a, b), axis = 0) #row wise\n",
    "\n",
    "print(\"\\nArray after column wise joining is : \\n\", combination1)\n",
    "\n",
    "print(\"\\nArray after row wise joining is : \\n\", combination2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cab5448d",
   "metadata": {},
   "source": [
    "# - Joining array using stack functions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ba9f4ea",
   "metadata": {},
   "source": [
    "- It includes \n",
    "1. stack()\n",
    "2. hstack()\n",
    "3. vstack()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f8b96d5",
   "metadata": {},
   "source": [
    "# 1. stack() "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "758e7539",
   "metadata": {},
   "source": [
    "- We pass a sequence of arrays that we want to join to the stack() method along with the axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dbc3d8f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "First array is : \n",
      " [1 2 3]\n",
      "\n",
      "Second array is : \n",
      " [4 5 6]\n",
      "\n",
      "Array after joining is : \n",
      " [[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating first array\n",
    "arr1 = np.array([1, 2, 3])\n",
    "print(\"\\nFirst array is : \\n\", arr1)\n",
    "\n",
    "# creating second array\n",
    "arr2 = np.array([4, 5, 6])\n",
    "print(\"\\nSecond array is : \\n\", arr2)\n",
    "\n",
    "#Joins two array\n",
    "arr = np.stack((arr1, arr2))\n",
    "\n",
    "print(\"\\nArray after joining is : \\n\", arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d89114e",
   "metadata": {},
   "source": [
    "# 2. hstack() :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94458ebb",
   "metadata": {},
   "source": [
    "- hstack() to stack along rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "024c3a18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "First array is : \n",
      " [1 2 3]\n",
      "\n",
      "Second array is : \n",
      " [4 5 6]\n",
      "\n",
      "Array after joining is : \n",
      " [1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating first array\n",
    "arr1 = np.array([1, 2, 3])\n",
    "print(\"\\nFirst array is : \\n\", arr1)\n",
    "\n",
    "# creating second array\n",
    "arr2 = np.array([4, 5, 6])\n",
    "print(\"\\nSecond array is : \\n\", arr2)\n",
    "\n",
    "#Joins two array\n",
    "arr = np.hstack((arr1, arr2))\n",
    "\n",
    "print(\"\\nArray after joining is : \\n\", arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aff6e6f",
   "metadata": {},
   "source": [
    "# 3. vstack()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35c29708",
   "metadata": {},
   "source": [
    "- vstack()  to stack along columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "41e7f67b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "First array is : \n",
      " [1 2 3]\n",
      "\n",
      "Second array is : \n",
      " [4 5 6]\n",
      "\n",
      "Array after joining is : \n",
      " [[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating first array\n",
    "arr1 = np.array([1, 2, 3])\n",
    "print(\"\\nFirst array is : \\n\", arr1)\n",
    "\n",
    "# creating second array\n",
    "arr2 = np.array([4, 5, 6])\n",
    "print(\"\\nSecond array is : \\n\", arr2)\n",
    "\n",
    "#Joins two array\n",
    "arr = np.vstack((arr1, arr2))\n",
    "\n",
    "print(\"\\nArray after joining is : \\n\", arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b27285c0",
   "metadata": {},
   "source": [
    "# * NumPy Splitting Array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d4fbdcd",
   "metadata": {},
   "source": [
    "- Splitting is reverse operation of Joining.\n",
    "- Splitting breaks one array into multiple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ec94783d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "First array is : \n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]]\n",
      "\n",
      "Splitted array is : \n",
      "  [array([[1, 2, 3, 4],\n",
      "       [5, 6, 7, 8]]), array([[ 9, 10, 11, 12],\n",
      "       [13, 14, 15, 16]])]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    " \n",
    "a = np.arange(1,17).reshape(4,4)\n",
    "print(\"\\nFirst array is : \\n\", a)\n",
    "\n",
    "# splitting array\n",
    "split_array  = np.split(a, 2)\n",
    "print(\"\\nSplitted array is : \\n \", split_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05e338db",
   "metadata": {},
   "source": [
    "- splitting axis wise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a45623bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "First array is : \n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]]\n",
      "\n",
      "Splitted array is : \n",
      "  [array([[ 1,  2],\n",
      "       [ 5,  6],\n",
      "       [ 9, 10],\n",
      "       [13, 14]]), array([[ 3,  4],\n",
      "       [ 7,  8],\n",
      "       [11, 12],\n",
      "       [15, 16]])]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    " \n",
    "a = np.arange(1,17).reshape(4,4)\n",
    "print(\"\\nFirst array is : \\n\", a)\n",
    "\n",
    "# splitting array\n",
    "split_array  = np.split(a, 2, axis = 1)\n",
    "print(\"\\nSplitted array is : \\n \", split_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04e0e50b",
   "metadata": {},
   "source": [
    "- we can also splitt by giving specific index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e7e0d2f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Our array is : \n",
      " [11 22 33 55 77 88]\n",
      "\n",
      "Splitted array from specific index : \n",
      " [array([11]), array([22, 33, 55]), array([77, 88])]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# creating first array\n",
    "arr1 = np.array([11, 22, 33, 55, 77, 88])\n",
    "print(\"\\nOur array is : \\n\", arr1)\n",
    "\n",
    "s = np.split(arr1, [1, 4])\n",
    "print(\"\\nSplitted array from specific index : \\n\", s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84f6158a",
   "metadata": {},
   "source": [
    "# * Uniform Distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "189ddd57",
   "metadata": {},
   "source": [
    "- Used to describe probability where every event has equal chances of occuring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "efd42389",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Uniform distribution is  :\n",
      " [[0.35791199 0.75180069 0.5499788 ]\n",
      " [0.21427503 0.1443917  0.92782965]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.random.uniform(size=(2, 3))\n",
    "\n",
    "print(\"\\nUniform distribution is  :\\n\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18380fa2",
   "metadata": {},
   "source": [
    "# * Normal Distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c99c383c",
   "metadata": {},
   "source": [
    "It has three parameters:\n",
    "\n",
    "loc - (Mean) where the peak of the bell exists.\n",
    "\n",
    "scale - (Standard Deviation) how flat the graph distribution should be.\n",
    "\n",
    "size - The shape of the returned array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "4a4a5b07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Normal distribution is  :\n",
      " [[-2.70744266  0.52660553  0.63955233]\n",
      " [ 1.11610575 -0.16143204  0.73118651]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.random.normal(size=(2, 3))\n",
    "\n",
    "print(\"\\nNormal distribution is  :\\n\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dca5c147",
   "metadata": {},
   "source": [
    "- With parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "801f2a21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Normal distribution is  :\n",
      " [[2.23418009 3.34839238 3.06489241]\n",
      " [3.31374865 2.85085347 2.96059197]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.random.normal(loc=1, scale=2, size=(2, 3))\n",
    "\n",
    "print(\"\\nNormal distribution is  :\\n\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cf7d2d2",
   "metadata": {},
   "source": [
    "# * NumPy - String Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adc315e6",
   "metadata": {},
   "source": [
    "- All string method from python we can use here in numpy\n",
    "1. add()\n",
    "2. multiply()\n",
    "3. centre()\n",
    "4. lower() etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "8c29d4ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 1st array is :  ['Hello']\n",
      "The 2nd arrays is :  ['World']\n",
      "\n",
      "The concatenated array is : ['HelloWorld']\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "  \n",
    "# create the arrays\n",
    "x1 = ['Hello']\n",
    "x2 = ['World']\n",
    "print(\"The 1st array is : \", x1)\n",
    "\n",
    "print(\"The 2nd arrays is : \",x2)\n",
    "  \n",
    "# using the char.add() method\n",
    "# here char is module use to perform operation on string\n",
    "result = np.char.add(x1, x2)\n",
    "print(\"\\nThe concatenated array is :\", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "6f56fc61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The concatenated array is : ['hello']\n"
     ]
    }
   ],
   "source": [
    "result = np.char.lower(x1)\n",
    "print(\"\\nThe concatenated array is :\", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "a2eeb174",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The concatenated array is : ['WORLD']\n"
     ]
    }
   ],
   "source": [
    "result = np.char.upper(x2)\n",
    "print(\"\\nThe concatenated array is :\", result)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}