NPV DAY 1 NUMPY.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NPV DAY1 23-08-2021"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PANDAS-NUMPY(NUMERICAL PYTHON)-MATPLOTLIB-SEABORN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NUMPY IS THE CORE LIBRARY FOR SCIENTIFIC COMPUTING IN PYTHON.NUMPY IS GENERAL PURPOSE ARRAY(HOMOGENOUS BUT IN PYTHON-HETROGENEOUS) PROCESS PACKAGE-PERFORMS HIGH PERFORMANCE MULTIDEMENSIONAL ARRAY OBJECT AND TOOLS FOR WORKING WITH THESE ARRAY\n",
    "\n",
    "#### more powerful than pandas because of more libarary function but not beautiful to view\n",
    "\n",
    "#### conversion of numpy to pandas and pandas to numpy is easy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ARRAY-COVERS N DIMENSIONAL AND THEY ARE ITERABLE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1D ARRAY-SERIES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### shape(4,)-LOOK LIKE TUPPLE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2D ARRAY-DATA FRAME"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### shape(2,3)\n",
    "###### AXIS 0-ROWS\n",
    "###### AXIS 1-COLUMN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 3D ARRAY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### shape(4,3,2)\n",
    "###### AXIS 0-ROWS,AXIS 1,AXIS2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CREATION OF 1D,2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist1=[1,2,3,4,5]\n",
    "n1=np.array(mylist1)\n",
    "n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(n1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(n1.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5,)\n"
     ]
    }
   ],
   "source": [
    "print(n1.shape) #counts tuple of elements along each axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n"
     ]
    }
   ],
   "source": [
    "print(n1.dtype) #type of bits of each elements in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(n1.size) #total elements in array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(n1.itemsize) #size in bytes of each elements in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5], dtype=int8)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n2=np.array(mylist1,dtype=np.int8) #donot force a dtype\n",
    "n2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "1\n",
      "(5,)\n",
      "int32\n",
      "5\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "mylist1=[1,2,3,4,5]\n",
    "n1=np.array(mylist1)\n",
    "n1\n",
    "print(type(n1))\n",
    "print(n1.ndim)\n",
    "print(n1.shape)\n",
    "print(n1.dtype)\n",
    "print(n1.size)\n",
    "print(n1.itemsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "1\n",
      "(5,)\n",
      "float64\n",
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "mylist2=[1,2,3.89,4,5]\n",
    "n3=np.array(mylist2)\n",
    "n3\n",
    "print(type(n3))\n",
    "print(n3.ndim)\n",
    "print(n3.shape)\n",
    "print(n3.dtype)\n",
    "print(n3.size)\n",
    "print(n3.itemsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n"
     ]
    }
   ],
   "source": [
    "print(n3.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2D ARRAY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5, 3, 4], [9, 0, 0]]\n",
      "[[5 3 4]\n",
      " [9 0 0]]\n",
      "<class 'numpy.ndarray'>\n",
      "2\n",
      "(2, 3)\n",
      "int32\n",
      "6\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "mylist3=[[5,3,4],[9,0,0]]\n",
    "print(mylist3)\n",
    "\n",
    "n3=np.array(mylist3)\n",
    "print(n3)\n",
    "print(type(n3))\n",
    "print(n3.ndim)\n",
    "print(n3.shape)\n",
    "print(n3.dtype)\n",
    "print(n3.size)\n",
    "print(n3.itemsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 2D FLOAT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5.2, 3.0, 4.5], [9.1, 0.2, 0.3]]\n",
      "[[5.2 3.  4.5]\n",
      " [9.1 0.2 0.3]]\n",
      "<class 'numpy.ndarray'>\n",
      "2\n",
      "(2, 3)\n",
      "float64\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "mylist3=[[5.2,3.0,4.5],[9.1,0.2,0.3]]\n",
    "print(mylist3)\n",
    "\n",
    "n3=np.array(mylist3)\n",
    "print(n3)\n",
    "print(type(n3))\n",
    "print(n3.ndim)\n",
    "print(n3.shape)\n",
    "print(n3.dtype)\n",
    "print(n3.size)\n",
    "print(n3.itemsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 2D-COMPLEX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[(5+6j), 3, 4], [9, 0, 0]]\n",
      "[[5.+6.j 3.+0.j 4.+0.j]\n",
      " [9.+0.j 0.+0.j 0.+0.j]]\n",
      "<class 'numpy.ndarray'>\n",
      "2\n",
      "(2, 3)\n",
      "complex128\n",
      "6\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "mylist3=[[5+6j,3,4],[9,0,0]]\n",
    "print(mylist3)\n",
    "\n",
    "n3=np.array(mylist3)\n",
    "print(n3)\n",
    "print(type(n3))\n",
    "print(n3.ndim)\n",
    "print(n3.shape)\n",
    "print(n3.dtype)\n",
    "print(n3.size)\n",
    "print(n3.itemsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## USING RANGE-1D,2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(20,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1=np.arange(20)\n",
    "print(n1.shape)\n",
    "n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1=np.arange(10,20)\n",
    "print(n1.shape)\n",
    "n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1=np.arange(10,20,2)\n",
    "print(n1.shape)\n",
    "n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1.1 , 1.35, 1.6 , 1.85, 2.1 , 2.35, 2.6 , 2.85, 3.1 , 3.35, 3.6 ,\n",
       "       3.85])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1=np.arange(1.1,3.9,0.25) #numpy arange can be float\n",
    "print(n1.shape)\n",
    "n1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## USING RANGE-2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34=np.arange(12)\n",
    "print(n34.shape)\n",
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34=np.arange(12).reshape(3,4)\n",
    "print(n34.shape)\n",
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 6)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10, 11]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34=np.arange(12).reshape(2,6)\n",
    "print(n34.shape)\n",
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 12)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34=np.arange(12).reshape(1,12)\n",
    "print(n34.shape)\n",
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34=np.arange(12).reshape(4,-1) # -1 is instuction to calculate that dim internally/automatically\n",
    "print(n34.shape)\n",
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "n34=np.arange(12).reshape(-1,4) # -1 is instuction to calculate that dim internally/automatically\n",
    "print(n34.shape)\n",
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "can only specify one unknown dimension",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-49-d9a6a799908b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mn34\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m12\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# -1 is instuction to calculate that dim automatically\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn34\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mn34\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: can only specify one unknown dimension"
     ]
    }
   ],
   "source": [
    "n34=np.arange(12).reshape(-1,-1) # -1,-1 can not give -1,-1 at the same time as instuction to calculate that dim automatically\n",
    "print(n34.shape)\n",
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 6)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10, 11]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34=np.arange(12).reshape(-1,6) # -1 is instuction to calculate that dim automatically\n",
    "print(n34.shape)\n",
    "n34"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1D-RANDOM VALUES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([27, 46, 98, 65, 65, 30, 21, 31, 43, 56])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n10=np.random.randint(low=10,high=100,size=(10,))\n",
    "print(n10.shape)\n",
    "n10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([93, 50, 83, 64, 41, 86, 49, 35, 61, 16])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(23) #pseudo random number generator build in the system-\n",
    "n10=np.random.randint(low=10,high=100,size=(10,))\n",
    "print(n10.shape)\n",
    "n10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2D RANDOM VALUES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[93, 50, 83, 64],\n",
       "       [41, 86, 49, 35],\n",
       "       [61, 16, 55, 22]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(23) #pseudo random number generator build in the system-\n",
    "n10=np.random.randint(low=10,high=100,size=(3,4))\n",
    "print(n10.shape)\n",
    "n10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FLOAT "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0.51729788, 0.9469626 , 0.76545976, 0.28239584],\n",
       "       [0.22104536, 0.68622209, 0.1671392 , 0.39244247],\n",
       "       [0.61805235, 0.41193009, 0.00246488, 0.88403218]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(23) #pseudo random number generator build in the system-\n",
    "n10=np.random.rand(3,4)#uniform dist framework\n",
    "print(n10.shape)\n",
    "n10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0.66698806,  0.02581308, -0.77761941,  0.94863382],\n",
       "       [ 0.70167179, -1.05108156, -0.36754812, -1.13745969],\n",
       "       [-1.32214752,  1.77225828, -0.34745899,  0.67014016]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(23) #pseudo random number generator build in the system-\n",
    "n10=np.random.randn(3,4)#normal dist framework-BELL CURVE\n",
    "print(n10.shape)\n",
    "n10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n",
      "[[0.51729788 0.9469626  0.76545976 0.28239584]\n",
      " [0.22104536 0.68622209 0.1671392  0.39244247]\n",
      " [0.61805235 0.41193009 0.00246488 0.88403218]]\n",
      "0.002464881200886171\n",
      "0.9469626038148141\n",
      "0.4912870595645145\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(23) #pseudo random number generator build in the system-\n",
    "n10=np.random.rand(3,4)#uniform distribution framework i.e 0 to 1\n",
    "print(n10.shape)\n",
    "print(n10)\n",
    "print(n10.min())\n",
    "print(n10.max())\n",
    "print(n10.mean())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n",
      "[[ 0.66698806  0.02581308 -0.77761941  0.94863382]\n",
      " [ 0.70167179 -1.05108156 -0.36754812 -1.13745969]\n",
      " [-1.32214752  1.77225828 -0.34745899  0.67014016]]\n",
      "-1.3221475225908594\n",
      "1.7722582783074305\n",
      "-0.01815084181558928\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(23) #pseudo random number generator build in the system-\n",
    "n10=np.random.randn(3,4)#normal distribution framework-BELL CURVE i.e -1 to 1 mean tends to be 0\n",
    "print(n10.shape)\n",
    "print(n10)\n",
    "print(n10.min())\n",
    "print(n10.max())\n",
    "print(n10.mean())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 1, 0],\n",
       "       [0, 0, 1]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(3,dtype=np.int32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(shape=(3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(shape=(3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[55, 55, 55, 55],\n",
       "       [55, 55, 55, 55],\n",
       "       [55, 55, 55, 55]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full(shape=(3,4),fill_value=55)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty(shape=(3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[array([[1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.]]), array([[1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.]]), array([[1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.]]), array([[0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.]]), array([[4.17706815e+199, 7.26607065e+223, 9.10016856e+276,\n",
       "         1.27921601e-152],\n",
       "        [5.30450576e+006, 1.69042031e+195, 6.06117652e+097,\n",
       "         4.70100449e+180],\n",
       "        [1.87673453e-152, 2.72306853e-153, 1.66037154e+243,\n",
       "         1.76243998e+156]]), array([[1.14199446e+243, 1.29314588e+098, 4.70100449e+180,\n",
       "         1.87673453e-152],\n",
       "        [9.81925446e+025, 2.31431106e+251, 2.02799178e+267,\n",
       "         2.35290217e+251],\n",
       "        [6.57948823e-085, 3.30164407e+180, 3.81431017e+228,\n",
       "         1.39806874e-152]]), array([[9.28732492e-312, 3.16202013e-322, 0.00000000e+000,\n",
       "         0.00000000e+000],\n",
       "        [0.00000000e+000, 2.14622215e+184, 3.43770312e+179,\n",
       "         2.67818360e+184],\n",
       "        [1.54759802e-075, 1.85527303e-051, 4.69775794e-033,\n",
       "         2.47039549e-056]]), array([[4.73579358e+223, 3.41495614e+025, 9.77099376e-153,\n",
       "         1.38083749e+267],\n",
       "        [9.47751238e+170, 9.47359503e-154, 3.77280114e+233,\n",
       "         3.41486025e+025],\n",
       "        [9.77099376e-153, 1.38083749e+267, 7.24958760e+228,\n",
       "         6.21040961e+175]]), array([[2.64686546e+180, 1.99721148e+161, 1.38760003e+219,\n",
       "         2.21019329e+068],\n",
       "        [1.38582950e+219, 1.28325702e+194, 1.25691171e+266,\n",
       "         9.09136099e+276],\n",
       "        [2.52358626e-085, 5.46639334e+241, 6.01432367e+175,\n",
       "         8.81954402e+199]]), array([[2.11923013e+257, 1.74160576e-152, 4.44712982e+217,\n",
       "         1.76539954e+137],\n",
       "        [1.43573466e-023, 7.35876406e+223, 1.92085503e+136,\n",
       "         9.02193423e+217],\n",
       "        [3.69028917e+180, 1.57624840e-118, 3.25478943e+015,\n",
       "         5.01402579e+180]])]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empmat=[]\n",
    "for i in range(10):\n",
    "    empmat.append(np.empty(shape=(3,4)))\n",
    "print()\n",
    "empmat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "256\n",
      "4294967296\n",
      "18446744073709551616\n"
     ]
    }
   ],
   "source": [
    "## 8 bit=255\n",
    "print(2**8)\n",
    "print(2**32)\n",
    "print(2**64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ACCESSING A MATRIX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[93, 50, 83, 64, 41, 86, 49, 35, 61],\n",
       "       [16, 55, 22, 59, 76, 85, 95, 79, 74],\n",
       "       [22, 31, 58, 51, 89, 72, 67, 29, 43],\n",
       "       [69, 49, 25, 46, 75, 11, 53, 25, 96],\n",
       "       [93, 68, 35, 76, 84, 45, 66, 23, 70],\n",
       "       [32, 48, 41, 88, 10, 31, 16, 42, 42],\n",
       "       [24, 41, 88, 93, 90, 80, 76, 92, 95],\n",
       "       [65, 37, 72, 53, 84, 81, 52, 93, 31]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(23)\n",
    "n89=np.random.randint(low=10,high=100,size=(8,9))\n",
    "n89"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "ACCESS GRAMMER\n",
    "\n",
    "\n",
    "\n",
    "n89[ row_index]\n",
    "n89[ row_index, col_index ]\n",
    "\n",
    "n89[ row_slice ]\n",
    "n89[ row_slice,  col_slice ]\n",
    "\n",
    "n89[ [list of row indices]   ]\n",
    "\n",
    "n89[ [list of row indices], [[list of col indices]]] ## both same size.. values at zipped cordinates\n",
    "\n",
    "\n",
    "##  combo of all of above\n",
    "\n",
    "\n",
    "## Conditional Access\n",
    "n89[boolean matrix of same shape as n89]\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[93, 50, 83, 64, 41, 86, 49, 35, 61],\n",
       "       [16, 55, 22, 59, 76, 85, 95, 79, 74],\n",
       "       [22, 31, 58, 51, 89, 72, 67, 29, 43],\n",
       "       [69, 49, 25, 46, 75, 11, 53, 25, 96],\n",
       "       [93, 68, 35, 76, 84, 45, 66, 23, 70],\n",
       "       [32, 48, 41, 88, 10, 31, 16, 42, 42],\n",
       "       [24, 41, 88, 93, 90, 80, 76, 92, 95],\n",
       "       [65, 37, 72, 53, 84, 81, 52, 93, 31]])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(23)\n",
    "n89=np.random.randint(low=10,high=100,size=(8,9))\n",
    "n89"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([93, 50, 83, 64, 41, 86, 49, 35, 61])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[0] #n89[row-index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([16, 55, 22, 59, 76, 85, 95, 79, 74])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([65, 37, 72, 53, 84, 81, 52, 93, 31])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "93"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[0,0]#n89[row-index,col-index]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[0,1]#n89[row-index,col-index]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "61"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[0,-1]#n89[row-index,col-index]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[93, 50, 83, 64, 41, 86, 49, 35, 61],\n",
       "       [16, 55, 22, 59, 76, 85, 95, 79, 74],\n",
       "       [22, 31, 58, 51, 89, 72, 67, 29, 43],\n",
       "       [69, 49, 25, 46, 75, 11, 53, 25, 96],\n",
       "       [93, 68, 35, 76, 84, 45, 66, 23, 70],\n",
       "       [32, 48, 41, 88, 10, 31, 16, 42, 42],\n",
       "       [24, 41, 88, 93, 90, 80, 76, 92, 95],\n",
       "       [65, 37, 72, 53, 84, 81, 52, 93, 31]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(23)\n",
    "n89=np.random.randint(low=10,high=100,size=(8,9))\n",
    "n89"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[22, 31, 58, 51, 89, 72, 67, 29, 43],\n",
       "       [69, 49, 25, 46, 75, 11, 53, 25, 96],\n",
       "       [93, 68, 35, 76, 84, 45, 66, 23, 70]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[2:5]#n89[row_slice]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[22, 31, 58, 51, 89, 72, 67, 29, 43],\n",
       "       [93, 68, 35, 76, 84, 45, 66, 23, 70],\n",
       "       [24, 41, 88, 93, 90, 80, 76, 92, 95]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[2:7:2]#n89[row_slice] with step count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[69, 49, 25, 46, 75, 11, 53, 25, 96],\n",
       "       [93, 68, 35, 76, 84, 45, 66, 23, 70],\n",
       "       [32, 48, 41, 88, 10, 31, 16, 42, 42]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[3:6]#n89[row_slice]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[69, 49, 25, 46, 75, 11, 53, 25, 96],\n",
       "       [93, 68, 35, 76, 84, 45, 66, 23, 70],\n",
       "       [32, 48, 41, 88, 10, 31, 16, 42, 42]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[3:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[25, 46, 75, 11, 53, 25],\n",
       "       [35, 76, 84, 45, 66, 23],\n",
       "       [41, 88, 10, 31, 16, 42]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[ 3:6,2:8     ]#n89[row_slice,col_slice]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[93, 50, 83, 64, 41, 86, 49, 35, 61],\n",
       "       [22, 31, 58, 51, 89, 72, 67, 29, 43],\n",
       "       [24, 41, 88, 93, 90, 80, 76, 92, 95],\n",
       "       [65, 37, 72, 53, 84, 81, 52, 93, 31]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[[0,2,-2,-1]] #vectors #n89[list of row indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[93, 50, 83, 64, 41, 86, 49, 35, 61],\n",
       "       [22, 31, 58, 51, 89, 72, 67, 29, 43],\n",
       "       [24, 41, 88, 93, 90, 80, 76, 92, 95],\n",
       "       [65, 37, 72, 53, 84, 81, 52, 93, 31]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[[0,2,-2,-1]]#n89[list of row indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([93, 55, 92, 31])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[[0,1,-2,-1],[0,1,-2,-1]] #vector with vector i.e [0][0],[1][1],[-2][-2],[-1][-1] like a zip #n89[[list of row indices],[list of col indices]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 0), (1, 1), (-2, -2), (-1, -1)]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip([0,1,-2,-1],[0,1,-2,-1]))#values at the zip coordinates of row list and column list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([41, 76, 89, 75, 84, 10, 90, 84])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[:,4]#n89[list of row indices],[list of col indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[41, 86],\n",
       "       [76, 85],\n",
       "       [89, 72],\n",
       "       [75, 11],\n",
       "       [84, 45],\n",
       "       [10, 31],\n",
       "       [90, 80],\n",
       "       [84, 81]])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[:,4:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[50, 41, 49],\n",
       "       [55, 76, 95],\n",
       "       [31, 89, 67],\n",
       "       [49, 75, 53],\n",
       "       [68, 84, 66],\n",
       "       [48, 10, 16],\n",
       "       [41, 90, 76],\n",
       "       [37, 84, 52]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[:,[1,4,6]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[55, 59, 74],\n",
       "       [49, 46, 96],\n",
       "       [48, 88, 42]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[1:6:2,[1,3,-1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([], shape=(0, 9), dtype=int32)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[3:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[69, 49, 25, 46, 75, 11, 53, 25, 96]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[3:2:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['p', 'y', 't', 'h', 'o', 'n', 'w', 'o', 'r', 'l', 'd']"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist=list('pythonworld')\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['t', 'h', 'o']"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CONDITIONAL ACESS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask=n89>75"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True, False,  True, False, False,  True, False, False, False],\n",
       "       [False, False, False, False,  True,  True,  True,  True, False],\n",
       "       [False, False, False, False,  True, False, False, False, False],\n",
       "       [False, False, False, False, False, False, False, False,  True],\n",
       "       [ True, False, False,  True,  True, False, False, False, False],\n",
       "       [False, False, False,  True, False, False, False, False, False],\n",
       "       [False, False,  True,  True,  True,  True,  True,  True,  True],\n",
       "       [False, False, False, False,  True,  True, False,  True, False]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([93, 83, 86, 76, 85, 95, 79, 89, 96, 93, 76, 84, 88, 88, 93, 90, 80,\n",
       "       76, 92, 95, 84, 81, 93])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([93, 83, 86, 76, 85, 95, 79, 89, 96, 93, 76, 84, 88, 88, 93, 90, 80,\n",
       "       76, 92, 95, 84, 81, 93])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[n89>75]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([64, 86, 76, 74, 58, 72, 96, 68, 76, 84, 66, 70, 88, 88, 90, 80, 76,\n",
       "       92, 72, 84, 52])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[np.logical_and(n89>50,n89%2==0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([93, 83, 64, 86, 61, 55, 59, 76, 85, 95, 79, 74, 58, 51, 89, 72, 67,\n",
       "       69, 75, 53, 96, 93, 68, 76, 84, 66, 70, 88, 88, 93, 90, 80, 76, 92,\n",
       "       95, 65, 72, 53, 84, 81, 52, 93])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[np.logical_and(n89>50,1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MUTABILITY-NUMPY OBJECTS ARE MUTABLE I.E WE CAN UPDATE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   1,  667,  667,  667,  667,  667,  667,  667,  667],\n",
       "       [  16,   55,   22, 1000, 1001, 1002,   95,   79,   74],\n",
       "       [ 888,  888,  888,  888,  888,  888,  888,  888,  888],\n",
       "       [  69,   49,   25, 1006, 1007, 1008,   53,   25,   96],\n",
       "       [  93,   68,   35,   76,   84,   45,   66,   23,   70],\n",
       "       [  32,   48,   41,   88,   10,   31,   16,   42,   42],\n",
       "       [ 667,  667,  667,  667,  667,  667,  667,  667,  667],\n",
       "       [ 667,  667,  667,  667,  667,  667,  667,  667,    3]])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[2]=888\n",
    "n89"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1, 667, 667, 667, 667, 667, 667, 667, 667])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   1,  667,  667,  667,  667,  667,  667,  667,  667],\n",
       "       [  16,   55,   22, 5656, 5656, 5656,   95,   79,   74],\n",
       "       [ 888,  888,  888, 5656, 5656, 5656,  888,  888,  888],\n",
       "       [  69,   49,   25, 5656, 5656, 5656,   53,   25,   96],\n",
       "       [  93,   68,   35,   76,   84,   45,   66,   23,   70],\n",
       "       [  32,   48,   41,   88,   10,   31,   16,   42,   42],\n",
       "       [ 667,  667,  667,  667,  667,  667,  667,  667,  667],\n",
       "       [ 667,  667,  667,  667,  667,  667,  667,  667,    3]])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[1:4,3:6]=5656\n",
    "n89"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[667, 667, 667, 667, 667, 667, 667, 667, 667],\n",
       "       [ 16,  55,  22,  59,  76,  85,  95,  79,  74],\n",
       "       [888, 888, 888, 888, 888, 888, 888, 888, 888],\n",
       "       [ 69,  49,  25,  46,  75,  11,  53,  25,  96],\n",
       "       [ 93,  68,  35,  76,  84,  45,  66,  23,  70],\n",
       "       [ 32,  48,  41,  88,  10,  31,  16,  42,  42],\n",
       "       [667, 667, 667, 667, 667, 667, 667, 667, 667],\n",
       "       [667, 667, 667, 667, 667, 667, 667, 667, 667]])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[[0,-2,-1]]=667\n",
    "n89"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "n89[[0,-2,-1]]=np.random.randint(low=10,high=100,size=(3,9))\n",
    "n89"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 667,  667,  667,  667,  667,  667,  667,  667,  667],\n",
       "       [  16,   55,   22, 5656, 5656, 5656,   95,   79,   74],\n",
       "       [ 888,  888,  888, 5656, 5656, 5656,  888,  888,  888],\n",
       "       [  69,   49,   25, 5656, 5656, 5656,   53,   25,   96],\n",
       "       [  93,   68,   35,   76,   84,   45,   66,   23,   70],\n",
       "       [  32,   48,   41,   88,   10,   31,   16,   42,   42],\n",
       "       [ 667,  667,  667,  667,  667,  667,  667,  667,  667],\n",
       "       [ 667,  667,  667,  667,  667,  667,  667,  667,  667]])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[1:4,3:6]=5656\n",
    "n89"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 667,  667,  667,  667,  667,  667,  667,  667,  667],\n",
       "       [  16,   55,   22, 1000, 1001, 1002,   95,   79,   74],\n",
       "       [ 888,  888,  888, 1003, 1004, 1005,  888,  888,  888],\n",
       "       [  69,   49,   25, 1006, 1007, 1008,   53,   25,   96],\n",
       "       [  93,   68,   35,   76,   84,   45,   66,   23,   70],\n",
       "       [  32,   48,   41,   88,   10,   31,   16,   42,   42],\n",
       "       [ 667,  667,  667,  667,  667,  667,  667,  667,  667],\n",
       "       [ 667,  667,  667,  667,  667,  667,  667,  667,  667]])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(23)\n",
    "n89[1:4,3:6]=np.arange(1000,1009).reshape(3,3)\n",
    "n89"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([667, 667, 667, 667])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[[0,0,-1,-1],[0,0,-1,-1]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   1,  667,  667,  667,  667,  667,  667,  667,  667],\n",
       "       [  16,   55,   22, 1000, 1001, 1002,   95,   79,   74],\n",
       "       [ 888,  888,  888, 1003, 1004, 1005,  888,  888,  888],\n",
       "       [  69,   49,   25, 1006, 1007, 1008,   53,   25,   96],\n",
       "       [  93,   68,   35,   76,   84,   45,   66,   23,   70],\n",
       "       [  32,   48,   41,   88,   10,   31,   16,   42,   42],\n",
       "       [ 667,  667,  667,  667,  667,  667,  667,  667,  667],\n",
       "       [ 667,  667,  667,  667,  667,  667,  667,  667,    3]])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n89[[0,0,-1,-1],[0,0,-1,-1]]=np.arange(4)\n",
    "n89"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ARITHMETIC OPERATIONS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[100 101 102 103 104 105 106 107 108 109]\n"
     ]
    }
   ],
   "source": [
    "n1=np.arange(10)\n",
    "n2=np.arange(100,110)\n",
    "print(n1)\n",
    "print(n2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100, 102, 104, 106, 108, 110, 112, 114, 116, 118])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1+n2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n34a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n34a-n34b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n34a*n34b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n34a+n34b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1221"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "111*11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## m,n@n,k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### COMPARING LIST OPERATION WITH NUMPY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist1=list(range(10000))\n",
    "mylist2=list(range(10000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n"
     ]
    }
   ],
   "source": [
    "mylist3=[mylist1[i]+mylist2[i] for i in range(10000)]\n",
    "print(len(mylist3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n",
      "time taken 0.0\n",
      "10000\n"
     ]
    }
   ],
   "source": [
    "size=500000\n",
    "mylist1=list(range(10000))\n",
    "mylist2=list(range(10000))\n",
    "\n",
    "st=time.time()\n",
    "\n",
    "mylist3=[mylist1[i]+mylist2[i] for i in range(10000)]\n",
    "et=time.time()\n",
    "print(len(mylist3))\n",
    "\n",
    "\n",
    "print('time taken',et-st)\n",
    "\n",
    "print(len(mylist3))\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np time taken 0.0\n"
     ]
    }
   ],
   "source": [
    "size=500000\n",
    "mylist1=list(range(10000))\n",
    "mylist2=list(range(10000))\n",
    "\n",
    "n1=np.array(mylist1)\n",
    "n2=np.array(mylist2)\n",
    "st=time.time()\n",
    "n3=n1+n2\n",
    "et=time.time()\n",
    "print('np time taken',et-st)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n",
      "time taken 0.0\n",
      "10000\n",
      "np time taken 0.0\n"
     ]
    }
   ],
   "source": [
    "size=500000\n",
    "mylist1=list(range(10000))\n",
    "mylist2=list(range(10000))\n",
    "\n",
    "st=time.time()\n",
    "\n",
    "mylist3=[mylist1[i]+mylist2[i] for i in range(10000)]\n",
    "et=time.time()\n",
    "print(len(mylist3))\n",
    "\n",
    "\n",
    "print('time taken',et-st)\n",
    "\n",
    "print(len(mylist3))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "n1=np.array(mylist1)\n",
    "n2=np.array(mylist2)\n",
    "st=time.time()\n",
    "n3=n1+n2\n",
    "et=time.time()\n",
    "print('np time taken',et-st)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BROADCASTING"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SCALAR BROADCASTING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34=np.arange(12).reshape(3,4)\n",
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[100, 101, 102, 103],\n",
       "       [104, 105, 106, 107],\n",
       "       [108, 109, 110, 111]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34+100 #100 is added to every element 100 is a scalar value is added-SCALAR BROADCASTING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1000],\n",
       "       [1001],\n",
       "       [1002]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n31=np.arange(1000,1003).reshape(3,1)\n",
    "n31"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1000, 1001, 1002, 1003],\n",
       "       [1005, 1006, 1007, 1008],\n",
       "       [1010, 1011, 1012, 1013]])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34+n31 #axis 1 broadcasting or streching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2000, 2001, 2002, 2003]])"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n14=np.arange(2000,2004).reshape(1,4)\n",
    "n14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2000, 2002, 2004, 2006],\n",
       "       [2004, 2006, 2008, 2010],\n",
       "       [2008, 2010, 2012, 2014]])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34+n14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100 101 102]]\n",
      "\n",
      "[[200]\n",
      " [201]\n",
      " [202]\n",
      " [203]]\n"
     ]
    }
   ],
   "source": [
    "n13=np.arange(100,103).reshape(1,3)\n",
    "n41=np.arange(200,204).reshape(4,1)\n",
    "\n",
    "print(n13)\n",
    "print()\n",
    "print(n41)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[300, 301, 302],\n",
       "       [301, 302, 303],\n",
       "       [302, 303, 304],\n",
       "       [303, 304, 305]])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n13+n41 #both axis streching or broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2D STACKING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n23=np.arange(6).reshape(2,3)\n",
    "n23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[100, 101, 102],\n",
       "       [103, 104, 105],\n",
       "       [106, 107, 108],\n",
       "       [109, 110, 111]])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n43=np.arange(100,112).reshape(4,3)\n",
    "n43"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### VSTACK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2],\n",
       "       [  3,   4,   5],\n",
       "       [100, 101, 102],\n",
       "       [103, 104, 105],\n",
       "       [106, 107, 108],\n",
       "       [109, 110, 111]])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=np.vstack((n23,n43))\n",
    "print(n.shape)\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2],\n",
       "       [  3,   4,   5],\n",
       "       [100, 101, 102],\n",
       "       [103, 104, 105],\n",
       "       [106, 107, 108],\n",
       "       [109, 110, 111]])"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=np.vstack(tup=(n23,n43))\n",
    "print(n.shape)\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "n34=np.arange(12).reshape(3,4)\n",
    "n36=np.arange(100,118).reshape(3,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[100, 101, 102, 103, 104, 105],\n",
       "       [106, 107, 108, 109, 110, 111],\n",
       "       [112, 113, 114, 115, 116, 117]])"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n36"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### HSTACK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 10)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2],\n",
       "       [  3,   4,   5],\n",
       "       [100, 101, 102],\n",
       "       [103, 104, 105],\n",
       "       [106, 107, 108],\n",
       "       [109, 110, 111]])"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=np.hstack((n34,n36))\n",
    "print(a.shape)\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 10)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2],\n",
       "       [  3,   4,   5],\n",
       "       [100, 101, 102],\n",
       "       [103, 104, 105],\n",
       "       [106, 107, 108],\n",
       "       [109, 110, 111]])"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=np.hstack(tup=(n34,n36))\n",
    "print(a.shape)\n",
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### COLUM_STACK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "n1=np.array([10,11,12,13])\n",
    "n2=np.array([110,111,112,113])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 11, 12, 13])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([110, 111, 112, 113])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 10, 110],\n",
       "       [ 11, 111],\n",
       "       [ 12, 112],\n",
       "       [ 13, 113]])"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.column_stack(tup=(n1,n2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ROW STACK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 10,  11,  12,  13],\n",
       "       [110, 111, 112, 113]])"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.row_stack(tup=(n1,n2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SPLITTING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],\n",
       "       [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n",
       "       [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35],\n",
       "       [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47],\n",
       "       [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59],\n",
       "       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71],\n",
       "       [72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83],\n",
       "       [84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95]])"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n8_12=np.arange(96).reshape(8,12)\n",
    "n8_12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EVEN SPLITTING-VSPLIT,HSPLIT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### VSPLIT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "n=np.vsplit(n8_12,4)\n",
    "print(type(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2]\n",
      " [12 13 14]\n",
      " [24 25 26]\n",
      " [36 37 38]\n",
      " [48 49 50]\n",
      " [60 61 62]\n",
      " [72 73 74]\n",
      " [84 85 86]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 3)\n",
      "\n",
      "[[ 3  4]\n",
      " [15 16]\n",
      " [27 28]\n",
      " [39 40]\n",
      " [51 52]\n",
      " [63 64]\n",
      " [75 76]\n",
      " [87 88]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 2)\n",
      "\n",
      "[[ 5]\n",
      " [17]\n",
      " [29]\n",
      " [41]\n",
      " [53]\n",
      " [65]\n",
      " [77]\n",
      " [89]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 1)\n",
      "\n",
      "[[ 6  7  8]\n",
      " [18 19 20]\n",
      " [30 31 32]\n",
      " [42 43 44]\n",
      " [54 55 56]\n",
      " [66 67 68]\n",
      " [78 79 80]\n",
      " [90 91 92]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 3)\n",
      "\n",
      "[[ 9 10]\n",
      " [21 22]\n",
      " [33 34]\n",
      " [45 46]\n",
      " [57 58]\n",
      " [69 70]\n",
      " [81 82]\n",
      " [93 94]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 2)\n",
      "\n",
      "[[11]\n",
      " [23]\n",
      " [35]\n",
      " [47]\n",
      " [59]\n",
      " [71]\n",
      " [83]\n",
      " [95]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 1)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for item in n:\n",
    "    print(item)\n",
    "    print(type(item))\n",
    "    print(item.shape)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 12)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],\n",
       "       [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n",
       "       [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35],\n",
       "       [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]])"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=np.vsplit(n8_12,2)\n",
    "print(n[0].shape)\n",
    "n[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### HSPLIT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8, 6)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [12, 13, 14, 15, 16, 17],\n",
       "       [24, 25, 26, 27, 28, 29],\n",
       "       [36, 37, 38, 39, 40, 41],\n",
       "       [48, 49, 50, 51, 52, 53],\n",
       "       [60, 61, 62, 63, 64, 65],\n",
       "       [72, 73, 74, 75, 76, 77],\n",
       "       [84, 85, 86, 87, 88, 89]])"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=np.hsplit(n8_12,2)\n",
    "print(n[0].shape)\n",
    "n[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8, 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [12, 13, 14, 15],\n",
       "       [24, 25, 26, 27],\n",
       "       [36, 37, 38, 39],\n",
       "       [48, 49, 50, 51],\n",
       "       [60, 61, 62, 63],\n",
       "       [72, 73, 74, 75],\n",
       "       [84, 85, 86, 87]])"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=np.hsplit(n8_12,3)\n",
    "print(n[0].shape)\n",
    "n[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## UNEVEN SPLITTING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],\n",
       "       [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n",
       "       [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35],\n",
       "       [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47],\n",
       "       [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59],\n",
       "       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71],\n",
       "       [72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83],\n",
       "       [84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95]])"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n8_12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=np.hsplit(n8_12,[3,5,6,9,11]) #:356911\n",
    "len(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2]\n",
      " [12 13 14]\n",
      " [24 25 26]\n",
      " [36 37 38]\n",
      " [48 49 50]\n",
      " [60 61 62]\n",
      " [72 73 74]\n",
      " [84 85 86]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 3)\n",
      "\n",
      "[[ 3  4]\n",
      " [15 16]\n",
      " [27 28]\n",
      " [39 40]\n",
      " [51 52]\n",
      " [63 64]\n",
      " [75 76]\n",
      " [87 88]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 2)\n",
      "\n",
      "[[ 5]\n",
      " [17]\n",
      " [29]\n",
      " [41]\n",
      " [53]\n",
      " [65]\n",
      " [77]\n",
      " [89]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 1)\n",
      "\n",
      "[[ 6  7  8]\n",
      " [18 19 20]\n",
      " [30 31 32]\n",
      " [42 43 44]\n",
      " [54 55 56]\n",
      " [66 67 68]\n",
      " [78 79 80]\n",
      " [90 91 92]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 3)\n",
      "\n",
      "[[ 9 10]\n",
      " [21 22]\n",
      " [33 34]\n",
      " [45 46]\n",
      " [57 58]\n",
      " [69 70]\n",
      " [81 82]\n",
      " [93 94]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 2)\n",
      "\n",
      "[[11]\n",
      " [23]\n",
      " [35]\n",
      " [47]\n",
      " [59]\n",
      " [71]\n",
      " [83]\n",
      " [95]]\n",
      "<class 'numpy.ndarray'>\n",
      "(8, 1)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for item in n:\n",
    "    print(item)\n",
    "    print(type(item))\n",
    "    print(item.shape)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[ 0,  1],\n",
       "        [12, 13],\n",
       "        [24, 25],\n",
       "        [36, 37],\n",
       "        [48, 49],\n",
       "        [60, 61],\n",
       "        [72, 73],\n",
       "        [84, 85]]), array([[ 2,  3,  4],\n",
       "        [14, 15, 16],\n",
       "        [26, 27, 28],\n",
       "        [38, 39, 40],\n",
       "        [50, 51, 52],\n",
       "        [62, 63, 64],\n",
       "        [74, 75, 76],\n",
       "        [86, 87, 88]]), array([[ 5],\n",
       "        [17],\n",
       "        [29],\n",
       "        [41],\n",
       "        [53],\n",
       "        [65],\n",
       "        [77],\n",
       "        [89]]), array([[ 6],\n",
       "        [18],\n",
       "        [30],\n",
       "        [42],\n",
       "        [54],\n",
       "        [66],\n",
       "        [78],\n",
       "        [90]]), array([[ 7,  8,  9],\n",
       "        [19, 20, 21],\n",
       "        [31, 32, 33],\n",
       "        [43, 44, 45],\n",
       "        [55, 56, 57],\n",
       "        [67, 68, 69],\n",
       "        [79, 80, 81],\n",
       "        [91, 92, 93]]), array([[10, 11],\n",
       "        [22, 23],\n",
       "        [34, 35],\n",
       "        [46, 47],\n",
       "        [58, 59],\n",
       "        [70, 71],\n",
       "        [82, 83],\n",
       "        [94, 95]])]"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1=np.hsplit(n8_12,[2,5,6,7,10]) #:2:5:6:7:10\n",
    "n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],\n",
       "        [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n",
       "        [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]]),\n",
       " array([[36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]]),\n",
       " array([[48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59],\n",
       "        [60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71],\n",
       "        [72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83],\n",
       "        [84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95]])]"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vsplit(n8_12,[3,4]) #:3:4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AGGREGATION FUNCTIONS(AGGREGATE)-FACTORIAL,SUM,MAX,MIN,MEDIAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24, 43, 14, 36],\n",
       "       [17, 32, 44, 31],\n",
       "       [30, 11, 17,  7]])"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(23)\n",
    "n34=np.random.randint(low=5,high=45,size=(3,4))\n",
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([117, 124,  65])"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(n34,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "306"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(n34,axis=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([71, 86, 75, 74])"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(n34,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "306\n",
      "[71 86 75 74]\n",
      "[117 124  65]\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(n34,axis=None))\n",
    "print(np.sum(n34,axis=0))\n",
    "print(np.sum(n34,axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.5\n",
      "[23.66666667 28.66666667 25.         24.66666667]\n",
      "[29.25 31.   16.25]\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(n34,axis=None))\n",
    "print(np.mean(n34,axis=0))\n",
    "print(np.mean(n34,axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.84271928232701\n",
      "[ 5.31245915 13.27487183 13.49073756 12.6578917 ]\n",
      "[11.12148821  9.56556323  8.69985632]\n"
     ]
    }
   ],
   "source": [
    "print(np.std(n34,axis=None))\n",
    "print(np.std(n34,axis=0))\n",
    "print(np.std(n34,axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140.25\n",
      "[ 28.22222222 176.22222222 182.         160.22222222]\n",
      "[123.6875  91.5     75.6875]\n"
     ]
    }
   ],
   "source": [
    "print(np.var(n34,axis=None))\n",
    "print(np.var(n34,axis=0))\n",
    "print(np.var(n34,axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "[17 11 14  7]\n",
      "[14 17  7]\n"
     ]
    }
   ],
   "source": [
    "print(np.min(n34,axis=None))\n",
    "print(np.min(n34,axis=0))\n",
    "print(np.min(n34,axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## UTILITY FUNCTION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      0., 1000000., 2000000., 3000000., 4000000., 5000000.])"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(start=0,stop=5000000,num=6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000000.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([      0., 1000000., 2000000., 3000000., 4000000., 5000000.])"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n=np.linspace(start=0,stop=5000000,num=6,retstep=True)\n",
    "print(n[-1])\n",
    "n[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([-1. , -0.5,  0. ,  0.5,  1. ])"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=np.linspace(start=-1,stop=1,num=5,retstep=True)\n",
    "print(a[-1])\n",
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#an=a0+(n-1)d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.907755278982137"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log10(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24, 43, 14, 36],\n",
       "       [17, 32, 44, 31],\n",
       "       [30, 11, 17,  7]])"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3.17805383, 3.76120012, 2.63905733, 3.58351894],\n",
       "       [2.83321334, 3.4657359 , 3.78418963, 3.4339872 ],\n",
       "       [3.40119738, 2.39789527, 2.83321334, 1.94591015]])"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(n34)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.38021124, 1.63346846, 1.14612804, 1.5563025 ],\n",
       "       [1.23044892, 1.50514998, 1.64345268, 1.49136169],\n",
       "       [1.47712125, 1.04139269, 1.23044892, 0.84509804]])"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log10(n34)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n23=np.array([100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.38905609893065"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.64891221e+10, 4.72783947e+18, 1.20260428e+06, 4.31123155e+15],\n",
       "       [2.41549528e+07, 7.89629602e+13, 1.28516001e+19, 2.90488497e+13],\n",
       "       [1.06864746e+13, 5.98741417e+04, 2.41549528e+07, 1.09663316e+03]])"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(n34)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1096.6331584284583"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.e**7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### iterations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[24 43 14 36]\n",
      "\n",
      "[17 32 44 31]\n",
      "\n",
      "[30 11 17  7]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for item in n34:\n",
    "    print(item)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "43\n",
      "14\n",
      "36\n",
      "17\n",
      "32\n",
      "44\n",
      "31\n",
      "30\n",
      "11\n",
      "17\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for element in np.nditer(n34):\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[24 43 14 36]\n",
      " [17 32 44 31]\n",
      " [30 11 17  7]]\n",
      "(0, 0) 24\n",
      "(0, 1) 43\n",
      "(0, 2) 14\n",
      "(0, 3) 36\n",
      "(1, 0) 17\n",
      "(1, 1) 32\n",
      "(1, 2) 44\n",
      "(1, 3) 31\n",
      "(2, 0) 30\n",
      "(2, 1) 11\n",
      "(2, 2) 17\n",
      "(2, 3) 7\n"
     ]
    }
   ],
   "source": [
    "print(n34)\n",
    "for index,value in np.ndenumerate(n34):\n",
    "    print(index,value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### INSERT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24, 43, 14, 36],\n",
       "       [17, 32, 44, 31],\n",
       "       [30, 11, 17,  7]])"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### insert a row "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[24 43 14 36]\n",
      " [ 0  1  2  3]\n",
      " [17 32 44 31]\n",
      " [30 11 17  7]]\n"
     ]
    }
   ],
   "source": [
    "n=np.insert(n34,1,[0,1,2,3],axis=0)\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 24  43  14  36]\n",
      " [999 999 999 999]\n",
      " [ 17  32  44  31]\n",
      " [ 30  11  17   7]]\n"
     ]
    }
   ],
   "source": [
    "n=np.insert(n34,1,999,axis=0)#values take it as broadcasting\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24, 43, 14, 36],\n",
       "       [17, 32, 44, 31],\n",
       "       [30, 11, 17,  7]])"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n34.shape\n",
    "n34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[24 43 14 36]\n",
      " [ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [17 32 44 31]\n",
      " [30 11 17  7]]\n"
     ]
    }
   ],
   "source": [
    "n=np.insert(n34,1,np.arange(8).reshape(2,4),axis=0)\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[24  0  3  6  9 43 14 36]\n",
      " [17  1  4  7 10 32 44 31]\n",
      " [30  2  5  8 11 11 17  7]]\n"
     ]
    }
   ],
   "source": [
    "n=np.insert(n34,1,np.arange(12).reshape(4,3),axis=1)\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3D MATRIX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1]\n",
      "  [ 2  3]\n",
      "  [ 4  5]\n",
      "  [ 6  7]]\n",
      "\n",
      " [[ 8  9]\n",
      "  [10 11]\n",
      "  [12 13]\n",
      "  [14 15]]\n",
      "\n",
      " [[16 17]\n",
      "  [18 19]\n",
      "  [20 21]\n",
      "  [22 23]]]\n"
     ]
    }
   ],
   "source": [
    "m342=np.arange(24).reshape(3,4,2)\n",
    "print(m342)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'list' object has no attribute 'shape'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-263-914ebe7c92af>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m           ]\n\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmylist342\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mmylist342\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'list' object has no attribute 'shape'"
     ]
    }
   ],
   "source": [
    "mylist342=[[11,31],[12,32],[13,33],[14,34],[15,35],[16,36],[17,37],[18,38],[19,39],[20,40],[21,41],[22,42]\n",
    "          ]\n",
    "print(len(mylist342))\n",
    ".shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n342=np.arange(24).reshape(4,3,2)\n",
    "n342.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n342"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n342[1,2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n342[1:,1:3,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n342a=np.arange(11,23).reshape(3,4)\n",
    "n342a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13, 14],\n",
       "       [15, 16, 17, 18],\n",
       "       [19, 20, 21, 22]])"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n342a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n342a=np.arange(11,23).reshape(3,4)\n",
    "n342a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=np.stack(arrays=)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi,Hello,How Are You?'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string='Hi,Hello,How Are You?'\n",
    "string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hi,Hello,How', 'Are', 'You?']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hi', 'Hello', 'How Are You?']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string.split(',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}