Numpy practise.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n",
      "[ 3  6  9 12 15]\n",
      "[ 1  4  9 16 25]\n"
     ]
    }
   ],
   "source": [
    "L = [1,2,3,4,5]           #<<----- a list \n",
    "A = np.array([1,2,3,4,5])   #<<----- numpy 1-D array \n",
    "B = np.array([6,7,8,9,10])\n",
    "\n",
    "## example Difference bw list and numpy_array:\n",
    "\n",
    "print(2*L)     #<------- gives new list cotaining duplicate of list L\n",
    "print(3*A)     #<------- actually multiplies each element in array by 3\n",
    "#print(L**2)   #<------- Not allowed to do such operation\n",
    "print(A**2)    #<------- works totally Fine!, squares each element in array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list: [1, 2, 3, 4, 5] \n",
      "numpy_array: [1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "print('list:', L, '\\nnumpy_array:', A)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A+B: [ 7  9 11 13 15]\n",
      "B-A: [5 5 5 5 5]\n",
      "2*A: [ 2  4  6  8 10]\n",
      "A*B: [ 6 14 24 36 50]\n",
      "A/2: [0.5 1.  1.5 2.  2.5]\n",
      "A**2: [ 1  4  9 16 25]\n"
     ]
    }
   ],
   "source": [
    "##list = [print(i) for i in A]\n",
    "\"\"\"\n",
    "        Arithmetic on 1-D array\n",
    "\"\"\"\"\n",
    "print('A+B:',  A+B)\n",
    "print('B-A:',  B-A)\n",
    "print('2*A:',  2*A)\n",
    "print('A*B:',  A*B)\n",
    "print('A/2:',  A/2)\n",
    "print('A**2:', A**2)   ##square of nums in array -->A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "\n",
      "[[ 9 10 11 12]\n",
      " [13 14 15 16]\n",
      " [17 18 19 20]]\n",
      "\n",
      "[[[ 0  1]\n",
      "  [ 2  3]\n",
      "  [ 4  5]]\n",
      "\n",
      " [[ 6  7]\n",
      "  [ 8  9]\n",
      "  [10 11]]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\" \n",
    "        N-D ndarray     axis-0 -->cols and axis-1 -->rows\n",
    "\"\"\"    \n",
    "M1 = np.arange(12).reshape(3,4)\n",
    "M2 = np.arange(9,21).reshape(3,4)\n",
    "M3 = np.arange(12).reshape(2,3,2)\n",
    "print(M1)\n",
    "print()\n",
    "print(M2)\n",
    "print()\n",
    "print(M3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 9 11 13]\n",
      " [15 17 19]]\n",
      "[ 5.          5.55555556  6.11111111  6.66666667  7.22222222  7.77777778\n",
      "  8.33333333  8.88888889  9.44444444 10.        ]\n",
      "[[0.         0.09090909]\n",
      " [0.18181818 0.27272727]\n",
      " [0.36363636 0.45454545]\n",
      " [0.54545455 0.63636364]\n",
      " [0.72727273 0.81818182]\n",
      " [0.90909091 1.        ]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "        arange func \n",
    "\"\"\"\n",
    "print(np.arange(9,21,2).reshape(2,3))\n",
    "\n",
    "\"\"\"\n",
    "        linspace func   --> we can specify the number of elements we want  and the step is decided automatically.\n",
    "\"\"\"\n",
    "print(np.linspace(5,10,10))              #<<--- 10 numbers in range 5 - 10 by default its 1-D array\n",
    "print(np.linspace(0,1,12).reshape(6,2))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4) (3, 4) (2, 3, 2)\n",
      "2\n",
      "12 12 12\n",
      "int32\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Attributes of ndarray\n",
    "\"\"\"\n",
    "print(M1.shape, M2.shape, M3.shape)\n",
    "print(M1.ndim)\n",
    "print(M1.size, M2.size, M3.size)\n",
    "print(M1.dtype)\n",
    "#print(M1.data)\n",
    "print(M1.itemsize) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "## ravel, flat methods --> iterate over each element in ndarray/matrix\n",
    "for item in M3.ravel() :   #<<-- same can be done with M3.flat\n",
    "    print(item)    \n",
    "    \n",
    "#print(M3.flat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "[[ 9 10 11 12]\n",
      " [13 14 15 16]\n",
      " [17 18 19 20]]\n",
      "add.:\n",
      " [[ 9 11 13 15]\n",
      " [17 19 21 23]\n",
      " [25 27 29 31]]\n",
      "sub.:\n",
      " [[9 9 9 9]\n",
      " [9 9 9 9]\n",
      " [9 9 9 9]]\n",
      "mul.:\n",
      " [[  0  10  22  36]\n",
      " [ 52  70  90 112]\n",
      " [136 162 190 220]]\n",
      "div:\n",
      " [[0.         0.1        0.18181818 0.25      ]\n",
      " [0.30769231 0.35714286 0.4        0.4375    ]\n",
      " [0.47058824 0.5        0.52631579 0.55      ]]\n",
      "horizontal stack:\n",
      " [[ 0  1  2  3  9 10 11 12]\n",
      " [ 4  5  6  7 13 14 15 16]\n",
      " [ 8  9 10 11 17 18 19 20]]\n",
      "vertical stack\n",
      " [[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]\n",
      " [17 18 19 20]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "        Arithmetic on 2-D array  -->> this will happen elementwise\n",
    "\"\"\"\n",
    "print(M1)\n",
    "print(M2)\n",
    "print('add.:\\n', M1+M2)\n",
    "print('sub.:\\n', M2-M1)\n",
    "print('mul.:\\n', M1*M2)\n",
    "print('div:\\n',  M1/M2)\n",
    "\n",
    "#stack m2 on m1 vertically and horizontally\n",
    "print('horizontal stack:\\n', np.hstack((M1,M2)))  #<<---- Note: args to stack func is tuple\n",
    "print('vertical stack\\n', np.vstack((M1,M2)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix mul.:\n",
      " [[17 13]\n",
      " [43 29]]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "        MATRIX MULTIPLICATION\n",
    "\"\"\"\n",
    "a = np.array([[1, 2], \n",
    "     [3, 4]])\n",
    "\n",
    "b = np.array([[9, 3], \n",
    "     [4, 5]] )\n",
    "\n",
    "c = np.dot(a,b)\n",
    "\n",
    "print(\"Matrix mul.:\\n\",a.dot(b))    #<<--------- This can be done by  np.dot(a,b) too!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M1:\n",
      " [[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "From all rows and only 1st colmn elements:\n",
      " [1 5 9]\n",
      "From cols 1 and 2 and only 1st row elements:\n",
      " [5 6]\n"
     ]
    }
   ],
   "source": [
    "# matrix Slicing:\n",
    "print('M1:\\n', M1)\n",
    "print('From all rows and only 1st colmn elements:\\n', M1[:,1])  \n",
    "print('From cols 1 and 2 and only 1st row elements:\\n', M1[1,1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zeros:\n",
      " [[0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n",
      "\n",
      "ones:\n",
      " [[1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1.]]\n",
      "\n",
      "[[9.2976095  3.17089824 8.25579114 1.98855987 5.71381899 5.89791523\n",
      "  4.45889171 0.38257608 2.88502947 1.73331424]\n",
      " [2.05035085 8.31435792 5.43834675 1.7516993  4.60140209 8.53037451\n",
      "  6.26628288 2.06013363 3.18744424 2.11763293]\n",
      " [7.20769818 4.05298628 3.03650742 8.90997436 4.92149631 8.07093588\n",
      "  5.16915374 4.0113633  5.44811907 9.47851791]\n",
      " [0.69622555 0.08296513 9.18703885 7.0564418  5.47029242 6.377213\n",
      "  0.38580986 3.64324261 5.09861081 0.7233076 ]\n",
      " [8.23930748 7.45091632 1.96786894 8.27970888 9.72608648 6.45404085\n",
      "  9.74872086 7.04930346 9.84307945 0.73130122]]\n",
      "\n",
      "[[5. 2. 1. 4. 4. 4. 9. 3. 2. 2.]\n",
      " [8. 0. 9. 5. 9. 7. 1. 4. 1. 6.]\n",
      " [7. 8. 8. 6. 4. 9. 8. 5. 9. 0.]\n",
      " [7. 0. 1. 5. 9. 1. 7. 8. 5. 6.]\n",
      " [8. 7. 2. 9. 0. 5. 4. 1. 4. 8.]]\n",
      "\n",
      "[[ 2.  2.  5.  1.  3.  8. 10.  5. 10.  7.]\n",
      " [ 8.  9.  1.  7.  5.  8.  6.  8.  6.  4.]\n",
      " [ 8.  6.  3.  7.  8.  1.  3.  6.  4.  2.]\n",
      " [ 8.  7.  2.  2.  9.  3.  9.  1.  5.  6.]\n",
      " [ 5.  9.  5.  4.  1.  3.  3. 10.  8. 10.]]\n"
     ]
    }
   ],
   "source": [
    "#generating matrices\n",
    "print('zeros:\\n', np.zeros((5,5)))            #<<---- Note: argument is tuple\n",
    "print()\n",
    "print('ones:\\n', np.ones((5,6)))\n",
    "print()\n",
    "\n",
    "#<<-----numbers bw 0 - 10----------->>#\n",
    "print(10*np.random.random((5,10)))   \n",
    "print()\n",
    "print(np.floor(10*np.random.random((5,10))))\n",
    "print()\n",
    "print(np.ceil((10*np.random.random((5,10)))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum of ele in M1: 66\n",
      "max ele in M1: 11\n",
      "min ele in M1: 0\n",
      "trace of mat M1: 15\n",
      "exp of each ele in M1:\n",
      " [[1.00000000e+00 2.71828183e+00 7.38905610e+00 2.00855369e+01]\n",
      " [5.45981500e+01 1.48413159e+02 4.03428793e+02 1.09663316e+03]\n",
      " [2.98095799e+03 8.10308393e+03 2.20264658e+04 5.98741417e+04]]\n",
      "\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      " \t+ \n",
      " [[ 9 10 11 12]\n",
      " [13 14 15 16]\n",
      " [17 18 19 20]] \n",
      " \t = \n",
      " [[ 9 11 13 15]\n",
      " [17 19 21 23]\n",
      " [25 27 29 31]]\n",
      "\n",
      "transpose of M1:\n",
      " [[ 0  4  8]\n",
      " [ 1  5  9]\n",
      " [ 2  6 10]\n",
      " [ 3  7 11]]\n",
      "a:\n",
      " [[1 2]\n",
      " [3 4]]\n",
      "inv, of a:\n",
      " [[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n",
      "I:\n",
      " [[1.0000000e+00 0.0000000e+00]\n",
      " [8.8817842e-16 1.0000000e+00]]\n",
      "\n",
      "mean for M1: 5.5\n",
      "variance for M1:\n",
      " 11.916666666666666\n",
      "standard deviation of M1:\n",
      " 3.452052529534663\n"
     ]
    }
   ],
   "source": [
    "#Some other matricx operations\n",
    "\n",
    "print('sum of ele in M1:', M1.sum())\n",
    "print('max ele in M1:', M1.max())\n",
    "print('min ele in M1:',M1.min())\n",
    "print('trace of mat M1:', M1.trace())\n",
    "print('exp of each ele in M1:\\n', np.exp(M1))\n",
    "print()\n",
    "print('{}\\n \\t+ \\n {} \\n \\t = \\n {}'.format(M1, M2, np.add(M1,M2)))\n",
    "print()\n",
    "\n",
    "# transpose\n",
    "print('transpose of M1:\\n',M1.T)\n",
    "\n",
    "#inverse\n",
    "print('a:\\n',a)\n",
    "a_inv = np.linalg.inv(a)\n",
    "print('inv, of a:\\n',a_inv)   #<<----- linalg(linear algebra) module\n",
    "\n",
    "#a_inv * a -->> I (unit matrix)\n",
    "print('I:\\n',np.dot(a,a_inv))\n",
    "\n",
    "#mean\n",
    "print('\\nmean for M1:',M1.mean())\n",
    "\n",
    "#variance\n",
    "print('variance for M1:\\n',M1.var())\n",
    "\n",
    "#standard deviation\n",
    "print('standard deviation of M1:\\n', np.std(M1) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: [[1 2]\n",
      " [3 4]]\n",
      "determinant of a: -2.0000000000000004\n",
      "diagonal elements of a: [1 4]\n",
      "diaginal matrix created:\n",
      " [[1 0 0]\n",
      " [0 2 0]\n",
      " [0 0 3]]\n",
      "\n",
      "outer mul:\n",
      " [[ 3  6  3  9]\n",
      " [ 4  8  4 12]\n",
      " [ 2  4  2  6]\n",
      " [ 4  8  4 12]]\n"
     ]
    }
   ],
   "source": [
    "#matrix operations continue'\n",
    "\n",
    "print('a:', a)\n",
    "print('determinant of a:', np.linalg.det(a))\n",
    "print('diagonal elements of a:', np.diag(a))\n",
    "print('diaginal matrix created:\\n', np.diag([1,2,3]))   #<<--- passing 1-D array to np.diag creates diagonal matrix with \n",
    "                                                        #       off diagonal elements as zero\n",
    "    \n",
    "#outer product --> multiplication of each element of mat1 with each element of mat2 forms a row\n",
    "print('\\nouter mul:\\n', np.outer([[3,4],[2,4]],\n",
    "                               [[1,2], [1,3]] ))\n",
    "\n",
    "#inner product is same as dot product    \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}