Numpy Practice.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "edd39733",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f98908eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3], dtype='int32')#This code is used to print a single dimensional array\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "25adc04c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9. 8. 7.]\n",
      " [6. 5. 4.]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([[9.0,8.0,7.0],[6.0,5.0,4.0]])#This code is used to print two dimensional array\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "78c3ffb1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get Dimension\n",
    "a.ndim #This code is used to print dimension of the given array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e39f7377",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.ndim #This code is used to print dimension of the given array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4b2d2087",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get Type\n",
    "a.dtype #It shows the datatype size in which the array is stored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "256bad45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get Size\n",
    "a.itemsize #It shows how many bytes the variable occupy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6380286c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get total size\n",
    "a.nbytes #It shows the total size occupied by the variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "121041f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get number of elements\n",
    "a.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3cff8b09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  5  7]\n",
      " [ 9 11 13 15 17]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3,5,7],[9,11,13,15,17]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "98018f43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[1,4]#used to find specific element[r,c]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4f6f9c95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 5 7]\n"
     ]
    }
   ],
   "source": [
    "print(a[0, :]) #used to find elements in a particlar row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "444d5c9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3 13]\n"
     ]
    }
   ],
   "source": [
    "print(a[:, 2]) #used to find elements in a particlar column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f53646ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30]\n"
     ]
    }
   ],
   "source": [
    "dt = np.dtype([('age',np.int8)]) #it uses file name to get the content in a particular column\n",
    "a = np.array([(10,),(20,),(30,)], dtype = dt) \n",
    "print (a['age'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "41a9486e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3],[4,5,6]]) \n",
    "a.shape = (3,2) #this resizes the array\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "bdf43961",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(24) \n",
    "print (a) #it prints the output which are evenly spaced"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "1ec6b473",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2]\n",
      "  [ 3  4  5]\n",
      "  [ 6  7  8]\n",
      "  [ 9 10 11]]\n",
      "\n",
      " [[12 13 14]\n",
      "  [15 16 17]\n",
      "  [18 19 20]\n",
      "  [21 22 23]]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(24) \n",
    "b = a.reshape(2,4,3) \n",
    "print (b)#this code reshapes the one dimensional array into three dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6e35926f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "a= np.array([1,2,3])\n",
    "print(a.min())# used to find minimum value in the array\n",
    "print(a.max())# used to find maximum value in the array\n",
    "print(a.sum())# used to find the sum of values in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f3119134",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 6 8]\n"
     ]
    }
   ],
   "source": [
    "a= np.array([(1,2,3),(3,4,5)])\n",
    "print(a.sum(axis=0))# sum of all values in the same columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3b0179ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         1.41421356 1.73205081]\n",
      " [1.73205081 2.         2.23606798]]\n",
      "1.2909944487358056\n"
     ]
    }
   ],
   "source": [
    "a=np.array([(1,2,3),(3,4,5,)])\n",
    "print(np.sqrt(a))#Square Root of the variables in the array\n",
    "print(np.std(a))#Standard Deviation of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a067e289",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0]\n",
      " [0 0 0]]\n",
      "[[ 1  4  9]\n",
      " [ 9 16 25]]\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "x= np.array([(1,2,3),(3,4,5)])\n",
    "y= np.array([(1,2,3),(3,4,5)])\n",
    "print(x-y)#subtraction of variables in an array\n",
    "print(x*y)#multiplication of variables in an array\n",
    "print(x/y)#division of variables in an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "07c1ac9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "x= np.array([(1,2,3),(3,4,5)])\n",
    "print(x.ravel())#it converts one numpy array into a single column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "bdfddf21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         1.22222222 1.44444444 1.66666667 1.88888889 2.11111111\n",
      " 2.33333333 2.55555556 2.77777778 3.        ]\n"
     ]
    }
   ],
   "source": [
    "a=np.linspace(1,3,10)\n",
    "print(a)#it returns evenly spaced numbers over a specified interval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d4ed96cb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = np.array([1,2])\n",
    "g = np.array([4,5])\n",
    "np.dot(f, g)#it returns the dot product of the two array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "46ced064",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 3]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.matrix('[1 , 2; 3, 4]')\n",
    "transpose = a.transpose()    \n",
    "print(transpose)#returns the transpose of the matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "454b5d50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5]]\n"
     ]
    }
   ],
   "source": [
    "a = np.matrix('[1, 2; 3, 4]')\n",
    "trace = a.trace()   \n",
    "print(trace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "3972fecc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.matrix('[1, 2; 3, 4]')\n",
    "diagonal = a.diagonal()   \n",
    "print(diagonal)#returns the diagonal of a matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "61f3ec79",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "np.linalg.matrix_rank(rank)#returns the rank of the matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "298d661d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d295528",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}