numpy_practice.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Arrays in NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array is of type:  <class 'numpy.ndarray'>\n",
      "No. of dimensions:  2\n",
      "Shape of array:  (2, 3)\n",
      "Size of array:  6\n",
      "Array stores elements of type:  int32\n"
     ]
    }
   ],
   "source": [
    "# creating array object\n",
    "arr=np.array([[1,2,3],[4,2,5]])\n",
    "\n",
    "print(\"Array is of type: \",type(arr))\n",
    "print(\"No. of dimensions: \",arr.ndim)\n",
    "print(\"Shape of array: \",arr.shape)\n",
    "print(\"Size of array: \",arr.size)\n",
    "print(\"Array stores elements of type: \",arr.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Array creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array created using passed list:\n",
      " [[1. 2. 4.]\n",
      " [5. 8. 7.]]\n",
      "\n",
      "Array created using passed tuple:\n",
      " [1 3 2]\n",
      "\n",
      "An array initialized with all zeros:\n",
      " [[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n",
      "\n",
      "An array initialized with all ones:\n",
      " [[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n",
      "\n",
      "An array having diagonal elements as one:\n",
      " [[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n",
      "\n",
      "An array initialized with all 6s. Array type is complex:\n",
      " [[6.+0.j 6.+0.j 6.+0.j]\n",
      " [6.+0.j 6.+0.j 6.+0.j]\n",
      " [6.+0.j 6.+0.j 6.+0.j]]\n",
      "\n",
      "A random array:\n",
      " [[0.65545852 0.6502315 ]\n",
      " [0.95551753 0.88736731]]\n",
      "\n",
      "A sequential array with steps of 5:\n",
      " [ 0  5 10 15 20 25]\n",
      "\n",
      "A sequential array with 10 values between 0 and 5:\n",
      " [0.         0.55555556 1.11111111 1.66666667 2.22222222 2.77777778\n",
      " 3.33333333 3.88888889 4.44444444 5.        ]\n",
      "\n",
      "Original array:\n",
      " [[1 2 3 4]\n",
      " [5 2 4 2]\n",
      " [1 2 0 1]]\n",
      "Reshaped array:\n",
      " [[[1 2 3]\n",
      "  [4 5 2]]\n",
      "\n",
      " [[4 2 1]\n",
      "  [2 0 1]]]\n",
      "\n",
      "Original array:\n",
      " [[1 2 3]\n",
      " [4 5 6]]\n",
      "Fattened array:\n",
      " [1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# creating array from list with type float\n",
    "a = np.array([[1, 2, 4], [5, 8, 7]], dtype = 'float')\n",
    "print(\"Array created using passed list:\\n\", a)\n",
    "\n",
    "# creating array from tuple\n",
    "b = np.array((1 , 3, 2))\n",
    "print(\"\\nArray created using passed tuple:\\n\", b)\n",
    "\n",
    "# creating a 3X4 array with all zeros\n",
    "c = np.zeros((3, 4))\n",
    "print(\"\\nAn array initialized with all zeros:\\n\", c)\n",
    "\n",
    "# creating a 3X4 array with all ones\n",
    "d=np.ones((3,4))\n",
    "print(\"\\nAn array initialized with all ones:\\n\", d)\n",
    "\n",
    "#create a 2-D array with ones on the diagonal and zeros elsewhere\n",
    "e=np.eye(3)\n",
    "print(\"\\nAn array having diagonal elements as one:\\n\", e)\n",
    "\n",
    "# create a constant value array of complex type\n",
    "f = np.full((3, 3), 6, dtype = 'complex')\n",
    "print(\"\\nAn array initialized with all 6s. Array type is complex:\\n\", f)\n",
    "\n",
    "# create an array with random values\n",
    "g = np.random.random((2,2))\n",
    "print(\"\\nA random array:\\n\", g)\n",
    "\n",
    "# create a sequence of integers from 0 to 30 with steps of 5\n",
    "h = np.arange(0, 30, 5)\n",
    "print(\"\\nA sequential array with steps of 5:\\n\", h)\n",
    "\n",
    "# create a sequence of 10 values in range 0 to 5\n",
    "i = np.linspace(0, 5, 10)\n",
    "print(\"\\nA sequential array with 10 values between 0 and 5:\\n\", i)\n",
    "\n",
    "# reshaping 3X4 array to 2X2X3 array\n",
    "arr = np.array([[1, 2, 3, 4],\n",
    "                [5, 2, 4, 2],\n",
    "                [1, 2, 0, 1]])\n",
    "newarr = arr.reshape(2, 2, 3)\n",
    "print(\"\\nOriginal array:\\n\", arr)\n",
    "print(\"Reshaped array:\\n\", newarr)\n",
    "\n",
    "# flatten array\n",
    "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "flarr = arr.flatten()\n",
    "print(\"\\nOriginal array:\\n\", arr)\n",
    "print(\"Fattened array:\\n\", flarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Array Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Original array:\n",
      " [[-1.   2.   0.   4. ]\n",
      " [ 4.  -0.5  6.   0. ]\n",
      " [ 2.6  0.   7.   8. ]\n",
      " [ 3.  -7.   4.   2. ]]\n",
      "Array with last 3 rows and alternate columns(0 and 2):\n",
      " [[4.  6. ]\n",
      " [2.6 7. ]\n",
      " [3.  4. ]]\n",
      "\n",
      "Elements at indices (0, 3), (1, 2), (2, 1), (3, 0):\n",
      " [4. 6. 0. 3.]\n",
      "\n",
      "Elements greater than 0:\n",
      " [2.  4.  4.  6.  2.6 7.  8.  3.  4.  2. ]\n"
     ]
    }
   ],
   "source": [
    "arr=np.array([[-1,2,0,4],[4,-0.5,6,0],[2.6,0,7,8],[3,-7,4,2]])\n",
    "print(\"\\nOriginal array:\\n\", arr)\n",
    "\n",
    "#slicing\n",
    "temp=arr[1:,:3:2]\n",
    "print(\"Array with last 3 rows and alternate columns(0 and 2):\\n\", temp)\n",
    "\n",
    "# integer array indexing example\n",
    "temp = arr[[0, 1, 2, 3], [3, 2, 1, 0]]\n",
    "print(\"\\nElements at indices (0, 3), (1, 2), (2, 1), (3, 0):\\n\", temp)\n",
    "\n",
    "# boolean array indexing example(cond is a boolean array)\n",
    "cond = arr > 0    \n",
    "temp = arr[cond]\n",
    "print(\"\\nElements greater than 0:\\n\", temp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Basic operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adding 1 to every element: [2 3 6 4]\n",
      "Multiplying each element by 3: [ 3  6 15  9]\n",
      "Doubled each element of original array: [ 2  4 10  6]\n",
      "\n",
      "Original array:\n",
      " [[1 2 3]\n",
      " [3 4 5]\n",
      " [9 6 0]]\n",
      "Transpose of array:\n",
      " [[1 3 9]\n",
      " [2 4 6]\n",
      " [3 5 0]]\n"
     ]
    }
   ],
   "source": [
    "a=np.array([1,2,5,3])\n",
    "\n",
    "# add 1 to every element\n",
    "print(\"Adding 1 to every element:\", a+1)\n",
    "\n",
    "# multiply each element by 3\n",
    "print(\"Multiplying each element by 3:\", a*3)\n",
    "\n",
    "# modify existing array\n",
    "a *= 2\n",
    "print(\"Doubled each element of original array:\", a)\n",
    "\n",
    "# transpose of array \n",
    "a = np.array([[1, 2, 3], [3, 4, 5], [9, 6, 0]])\n",
    "print(\"\\nOriginal array:\\n\", a)\n",
    "print(\"Transpose of array:\\n\", a.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Unary operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Largest element is: 9\n",
      "Row-wise maximum elements: [6 7 9]\n",
      "Column-wise minimum elements: [1 1 2]\n",
      "Sum of all array elements: 38\n",
      "Cumulative sum along each row:\n",
      " [[ 1  6 12]\n",
      " [ 4 11 13]\n",
      " [ 3  4 13]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,5,6],[4,7,2],[3,1,9]])\n",
    "\n",
    "# maximum element of array\n",
    "print(\"Largest element is:\", arr.max())\n",
    "print(\"Row-wise maximum elements:\", arr.max(axis = 1))\n",
    "\n",
    "# minimum element of array\n",
    "print(\"Column-wise minimum elements:\", arr.min(axis = 0))\n",
    "\n",
    "# sum of array elements\n",
    "print(\"Sum of all array elements:\", arr.sum())\n",
    "\n",
    "# cumulative sum along each row\n",
    "print(\"Cumulative sum along each row:\\n\", arr.cumsum(axis = 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Binary operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array sum:\n",
      " [[5 5]\n",
      " [5 5]]\n",
      "Array multiplication:\n",
      " [[4 6]\n",
      " [6 4]]\n",
      "Matrix multiplication:\n",
      " [[ 8  5]\n",
      " [20 13]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2],[3,4]])\n",
    "b = np.array([[4,3],[2,1]])\n",
    "\n",
    "# add arrays\n",
    "print(\"Array sum:\\n\", a + b)\n",
    "\n",
    "# multiply arrays\n",
    "print(\"Array multiplication:\\n\", a*b)\n",
    "\n",
    "# matrix multiplication\n",
    "print(\"Matrix multiplication:\\n\", a.dot(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Universal functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sine values of array elements: [0.0000000e+00 1.0000000e+00 1.2246468e-16]\n",
      "Exponent of array elements: [ 1.          2.71828183  7.3890561  20.08553692]\n",
      "Square root of array elements: [0.         1.         1.41421356 1.73205081]\n"
     ]
    }
   ],
   "source": [
    "# create an array of sine values\n",
    "a = np.array([0, np.pi/2, np.pi])\n",
    "print(\"Sine values of array elements:\", np.sin(a))\n",
    "\n",
    "# exponential values\n",
    "a = np.array([0, 1, 2, 3])\n",
    "print(\"Exponent of array elements:\", np.exp(a))\n",
    "\n",
    "# square root of array values\n",
    "print(\"Square root of array elements:\", np.sqrt(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Sorting arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array elements in sorted order:\n",
      " [-1  0  1  2  3  4  4  5  6]\n",
      "Row-wise sorted array:\n",
      " [[ 1  2  4]\n",
      " [ 3  4  6]\n",
      " [-1  0  5]]\n",
      "Column wise sort by applying merge-sort:\n",
      " [[ 0 -1  2]\n",
      " [ 1  4  5]\n",
      " [ 3  4  6]]\n",
      "\n",
      "Array sorted by names:\n",
      " [(b'Aakash', 2009, 9. ) (b'Ajay', 2008, 8.7) (b'Hrithik', 2009, 8.5)\n",
      " (b'Pankaj', 2008, 7.9)]\n",
      "Array sorted by grauation year and then cgpa:\n",
      " [(b'Pankaj', 2008, 7.9) (b'Ajay', 2008, 8.7) (b'Hrithik', 2009, 8.5)\n",
      " (b'Aakash', 2009, 9. )]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,4,2],[3,4,6],[0,-1,5]])\n",
    "\n",
    "# sorted array\n",
    "print(\"Array elements in sorted order:\\n\",np.sort(a,axis = None))\n",
    "\n",
    "# sort array row-wise\n",
    "print(\"Row-wise sorted array:\\n\",np.sort(a,axis = 1))\n",
    "\n",
    "# specify sort algorithm\n",
    "print(\"Column wise sort by applying merge-sort:\\n\", np.sort(a, axis = 0, kind = 'mergesort'))\n",
    "\n",
    "# example to show sorting of structured array\n",
    "## set alias names for dtypes\n",
    "dtypes = [('name', 'S10'), ('grad_year', int), ('cgpa', float)]\n",
    "\n",
    "## values to be put in array\n",
    "values = [('Hrithik', 2009, 8.5), ('Ajay', 2008, 8.7), ('Pankaj', 2008, 7.9), ('Aakash', 2009, 9.0)]\n",
    "\n",
    "## creating array\n",
    "arr = np.array(values, dtype = dtypes)\n",
    "print(\"\\nArray sorted by names:\\n\", np.sort(arr, order = 'name'))\n",
    "print(\"Array sorted by grauation year and then cgpa:\\n\", np.sort(arr, order = ['grad_year', 'cgpa']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Stacking and Splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vertical stacking:\n",
      " [[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n",
      "\n",
      "Horizontal stacking:\n",
      " [[1 2 5 6]\n",
      " [3 4 7 8]]\n",
      "\n",
      "Column stacking:\n",
      " [[1 2 5]\n",
      " [3 4 6]]\n",
      "\n",
      "Concatenating to 2nd axis:\n",
      " [[1 2 5 6]\n",
      " [3 4 7 8]]\n",
      "Splitting along horizontal axis into 2 parts:\n",
      " [array([[1, 3, 5],\n",
      "       [2, 4, 6]]), array([[ 7,  9, 11],\n",
      "       [ 8, 10, 12]])]\n",
      "\n",
      "Splitting along vertical axis into 2 parts:\n",
      " [array([[ 1,  3,  5,  7,  9, 11]]), array([[ 2,  4,  6,  8, 10, 12]])]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2],[3,4]])\n",
    "b = np.array([[5,6],[7,8]])\n",
    "\n",
    "# vertical stacking\n",
    "print(\"Vertical stacking:\\n\",np.vstack((a,b)))\n",
    "\n",
    "# horizontal stacking\n",
    "print(\"\\nHorizontal stacking:\\n\",np.hstack((a,b)))\n",
    "\n",
    "c = [5,6]\n",
    "\n",
    "# stacking columns\n",
    "print(\"\\nColumn stacking:\\n\", np.column_stack((a,c)))\n",
    "\n",
    "# concatenation method \n",
    "print(\"\\nConcatenating to 2nd axis:\\n\", np.concatenate((a,b),1))\n",
    "d = np.array([[1,3,5,7,9,11],[2,4,6,8,10,12]])\n",
    "\n",
    "# horizontal splitting\n",
    "print(\"Splitting along horizontal axis into 2 parts:\\n\", np.hsplit(d,2))\n",
    "\n",
    "# vertical splitting\n",
    "print(\"\\nSplitting along vertical axis into 2 parts:\\n\", np.vsplit(d,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Numpy functions(Statistics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [7 6 2 0]]\n",
      "0\n",
      "[1 2 2 0]\n",
      "[1 0]\n",
      "3.0\n",
      "3.0\n",
      "[4.  4.  2.5 2. ]\n",
      "[2.5  3.75]\n",
      "2.0\n",
      "2.4\n",
      "2.4\n",
      "1.854723699099141\n",
      "1.854723699099141\n",
      "3.440000000000001\n",
      "3.4400000000000004\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3,4],[7,6,2,0]])\n",
    "print(a)\n",
    "print(np.min(a))\n",
    "\n",
    "#Specify axis for the direction in case of multidim array\n",
    "print(np.min(a,axis=0))\n",
    "print(np.min(a,axis=1))\n",
    "\n",
    "b = np.array([1,2,3,4,5])\n",
    "m = sum(b)/5\n",
    "print(m)\n",
    "print(np.mean(b))\n",
    "print(np.mean(a,axis=0))\n",
    "print(np.mean(a,axis=1))\n",
    "\n",
    "c = np.array([1,5,4,2,0])\n",
    "print(np.median(c))\n",
    "\n",
    "# Mean vs Average is Weighted\n",
    "print(np.mean(c))\n",
    "\n",
    "# Weights \n",
    "w = np.array([1,1,1,1,1])\n",
    "print(np.average(c,weights=w))\n",
    "\n",
    "# weighted mean => n1*w1 + n2*w2 / n1+n2 \n",
    "# Standard Deviation\n",
    "d = np.mean(c)\n",
    "myStd = np.sqrt(np.mean(abs(c-d)**2))\n",
    "print(myStd)\n",
    "\n",
    "#Inbuilt Function\n",
    "e = np.std(c)\n",
    "print(e)\n",
    "\n",
    "#Variance\n",
    "print(myStd**2)\n",
    "print(np.var(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Numpy Random Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  6  7  8  9 10 11 12 13 14]\n",
      "[ 7 14 11  9  5  8  6 12 13 10]\n",
      "[[ 1.5827523  -1.04514683  0.25759352]\n",
      " [-1.9593946  -1.50780766 -0.31529207]]\n",
      "[7 9 6]\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(10) + 5\n",
    "print(a)\n",
    "\n",
    "np.random.seed(1)\n",
    "np.random.shuffle(a)\n",
    "print(a)\n",
    "\n",
    "#Returns values from a Standard Normal Distributions\n",
    "b = np.random.randn(2,3)\n",
    "print(b)\n",
    "\n",
    "c = np.random.randint(5,10,3)\n",
    "print(c)\n",
    "\n",
    "#Randoly pick one element from a array\n",
    "element = np.random.choice([1,4,3,2,11,27])\n",
    "print(element)"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}