Numpy Arrays.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6a6bb336",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Numpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4643d9e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7]\n",
      "<class 'numpy.ndarray'>\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "[[1. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0.]\n",
      " [0. 0. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 1.]]\n",
      "[0 1 2 3 4 5]\n",
      "[10.         11.11111111 12.22222222 13.33333333 14.44444444 15.55555556\n",
      " 16.66666667 17.77777778 18.88888889 20.        ]\n",
      "[10.         11.11111111 12.22222222 13.33333333 14.44444444 15.55555556\n",
      " 16.66666667 17.77777778 18.88888889 20.        ]\n"
     ]
    }
   ],
   "source": [
    "# Creating Numpy Arrays\n",
    "arr1 = np.array([1,2,3,4,5,6,7])\n",
    "\n",
    "\n",
    "# np.array takes a list as an argument and returns numpy.ndarray\n",
    "print(arr1)\n",
    "print(type(arr1))\n",
    "\n",
    "\n",
    "# Creating 2D nd array\n",
    "arr2 = np.array([[1,2,3],[4,5,6]])\n",
    "print(arr2)\n",
    "\n",
    "\n",
    "# np.zeros returns numpy.ndarray with 0 \"Order needs to be passed as an Argument\"\n",
    "# np.zeros((mxn) m---> rows , n---> colomns, Each Element will be a float\n",
    "arr3 = np.zeros((2,3))\n",
    "print(arr3)\n",
    "\n",
    "# np.ones returns same as np.zeros, but all elements as 1., floating numbers\n",
    "\n",
    "arr4 = np.ones((3,3))\n",
    "print(arr4)\n",
    "\n",
    "# np.identity takes a single Integral Argument and returns an Identity Matrix Of Such Order\n",
    "\n",
    "arr5 = np.identity(5)\n",
    "print(arr5)\n",
    "\n",
    "# np.arange(a,b,c) Take 3 args, a--> Initial, b--> Final, c--> Increment\n",
    "# Returns a numpy.ndarray in an specific order\n",
    "\n",
    "arr6 = np.arange(0,6)\n",
    "print(arr6)\n",
    "\n",
    "# np.linspace(a,b,c) Takes 3 args, a--> Initial, b--> Final, c--> Number Of Equidistant Points\n",
    "# Returns a nd array  with equidistant items between two points\n",
    "\n",
    "arr7 = np.linspace(10,20,10)\n",
    "print(arr7)\n",
    "\n",
    "# np.copy() copies one array into another array, np --> a numpy.ndarray object\n",
    "\n",
    "\n",
    "arr8 = arr7.copy()\n",
    "print(arr8)\n",
    "\n",
    "\n",
    "# Lecture 1 Over"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "076fa02e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7] \n",
      " (7,)\n",
      "[[1 2 3]\n",
      " [4 5 6]] \n",
      " (2, 3)\n",
      "[[[1 2 3]\n",
      "  [1 2 3]\n",
      "  [5 6 7]]\n",
      "\n",
      " [[3 4 5]\n",
      "  [3 4 6]\n",
      "  [5 7 9]]] \n",
      " (2, 3, 3)\n"
     ]
    }
   ],
   "source": [
    "# Numpy Array Properties\n",
    "# Shape arrObject.shape return (a,b,c) a--> n(Layers), b--> n(Rows), c--> n(Colomns)\n",
    "print(arr1,\"\\n\",arr1.shape) # 1X7 Matrix\n",
    "print(arr2,\"\\n\",arr2.shape) # 2X3 Matrix\n",
    "arr9 = np.array([[[1,2,3],[1,2,3],[5,6,7]],[[3,4,5],[3,4,6],[5,7,9]]])\n",
    "print(arr9,\"\\n\",arr9.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "49c2cab9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7] \n",
      " 1 \n",
      " [[1 2 3]\n",
      " [4 5 6]] \n",
      " 2 \n",
      " [[[1 2 3]\n",
      "  [1 2 3]\n",
      "  [5 6 7]]\n",
      "\n",
      " [[3 4 5]\n",
      "  [3 4 6]\n",
      "  [5 7 9]]] \n",
      " 3\n"
     ]
    }
   ],
   "source": [
    "# ndim Property Returns Dimension\n",
    "print(arr1,\"\\n\",arr1.ndim,\"\\n\",arr2,\"\\n\",arr2.ndim,\"\\n\",arr9,\"\\n\",arr9.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dcf36c37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7] \n",
      " 7 \n",
      " [[1 2 3]\n",
      " [4 5 6]] \n",
      " 6 \n",
      " [[[1 2 3]\n",
      "  [1 2 3]\n",
      "  [5 6 7]]\n",
      "\n",
      " [[3 4 5]\n",
      "  [3 4 6]\n",
      "  [5 7 9]]] \n",
      " 18\n"
     ]
    }
   ],
   "source": [
    "# arr.size Returns no. of items in nd array\n",
    "# Same as list len() function\n",
    "print(arr1,\"\\n\",arr1.size,\"\\n\",arr2,\"\\n\",arr2.size,\"\\n\",arr9,\"\\n\",arr9.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6fbf0a02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7] \n",
      " 8 \n",
      " [[0. 0. 0.]\n",
      " [0. 0. 0.]] \n",
      " 8\n"
     ]
    }
   ],
   "source": [
    "# arr.itemsize Returns size of individual items in that array\n",
    "# arr.itemsize : Returns 4(Int), 8(Float)\n",
    "print(arr1,\"\\n\",arr1.itemsize,\"\\n\",arr3,\"\\n\",arr3.itemsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "94f95371",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7] \n",
      " int64 \n",
      " [[0. 0. 0.]\n",
      " [0. 0. 0.]] \n",
      " float64\n"
     ]
    }
   ],
   "source": [
    "# arr.dtype Returns type of element in that array\n",
    "print(arr1,\"\\n\",arr1.dtype,\"\\n\",arr3,\"\\n\",arr3.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a1081477",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n"
     ]
    }
   ],
   "source": [
    "# arr.astype(\"Data Type To Change To\") Returns type of datatype you want to morph that array\n",
    "# arr1 --> Int64, arr1.astype(\"float\") --> Float64\n",
    "print(arr1.astype(\"float\").dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d6dcb36",
   "metadata": {},
   "source": [
    "Indexing, Slicing and Iteration In a numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a299908b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11],\n",
       "       [12, 13, 14, 15],\n",
       "       [16, 17, 18, 19],\n",
       "       [20, 21, 22, 23]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# arr12.reshape(m,n) allows us to reshape the given matrix in a specific order\n",
    "arr12 = np.arange(24).reshape(6,4)\n",
    "arr12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bdce0bea",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5  6]\n",
      " [ 9 10]]\n"
     ]
    }
   ],
   "source": [
    "# Accessing Particular Row and Coloumns using Slicing\n",
    "# Same Slicing Process as in normal list, but with extra columns given after comma \n",
    "print(arr12[1:3,1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4dc25406",
   "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",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n"
     ]
    }
   ],
   "source": [
    "# Iterating Over Data\n",
    "# Conventional Way\n",
    "for i in arr12:\n",
    "    for j in i:\n",
    "        print(j)\n",
    "\n",
    "# Using np.nditer        \n",
    "\n",
    "for i in np.nditer(arr12):\n",
    "    print(i)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "12eb5201",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 7  9 11]\n",
      " [13 15 17]]\n",
      "[[ True  True  True]\n",
      " [ True False False]]\n",
      "[[ 6 14 24]\n",
      " [36 50 66]]\n",
      "[[ 3  6  9]\n",
      " [12 15 18]]\n",
      "[[24 30 36]\n",
      " [51 66 81]]\n",
      "[6 7 8] [0 1 2]\n"
     ]
    }
   ],
   "source": [
    "# Numpy Array Operations (Follow Matrix Addition and Substraction)\n",
    "arr1=np.arange(1,7).reshape(2,3)\n",
    "arr2=np.arange(6,12).reshape(2,3)\n",
    "print(arr1+arr2)\n",
    "\n",
    "\n",
    "# Comparison with a constant returns a boolean array\n",
    "print(arr1 < 5)\n",
    "\n",
    "\n",
    "# Multiplication * Operator, Do Vector Multiplication\n",
    "print(arr1*arr2) # Consecutive Elements are multiplied\n",
    "\n",
    "\n",
    "# Multiplication with a constant\n",
    "print(3*arr1)\n",
    "\n",
    "# arrObject.dot(arrToMultiply) Returns a new array after matrix multiplication\n",
    "# Matrix Multiplication Rules Are Applied\n",
    "arr3=np.arange(9).reshape(3,3)\n",
    "print(arr1.dot(arr3))\n",
    "\n",
    "# arr1 is 2X3 and arr2 is 3X3, --> final array is returned with a 2X3 Matrix\n",
    "\n",
    "\n",
    "# arrObject.max() returns max element in that array, and same goes for min\n",
    "# axis = 0 represent x-axis and axis = 1 represents y-axis\n",
    "\n",
    "print(arr3.max(axis=0),arr3.min(axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "37075219",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36 21\n",
      "[ 3 12 21]\n"
     ]
    }
   ],
   "source": [
    "# To sum up all elements in that array, use arrObject.sum()\n",
    "print(arr3.sum(),arr3.max(axis=0).sum())\n",
    "# To print Row Wise Sum\n",
    "print(arr3.sum(axis=1))\n",
    "\n",
    "# To Calculate mean similarly we can use `arr4.mean()` and for standard deviation we can use `arr4.std()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3bb0b2f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "# Some numpy library functions applicable on numpy.ndarray's\n",
    "np.sin(arr3)\n",
    "print(np.median(arr3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ca0aaee3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3 16 35 88]\n",
      " [10 70 50 57]\n",
      " [52 80 17 98]\n",
      " [55 64 47 85]\n",
      " [96 88 95 65]]\n",
      "[ 3 16 35 88 10 70 50 57 52 80 17 98 55 64 47 85 96 88 95 65]\n",
      "[[ 3 10 52 55 96]\n",
      " [16 70 80 64 88]\n",
      " [35 50 17 47 95]\n",
      " [88 57 98 85 65]]\n"
     ]
    }
   ],
   "source": [
    "# Reshaping numpy.ndarrays\n",
    "# arrObject.ravel() --> Returns 1D array form nD array\n",
    "arr = np.random.randint(low=1,high=100,size=20).reshape(5,4)\n",
    "print(arr)\n",
    "print(arr.ravel())\n",
    "\n",
    "\n",
    "# To Take Transpose use --> arr4.transpose()\n",
    "\n",
    "print(arr.transpose())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c65ab3a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3 16 35 88  2 33 34 92]\n",
      " [10 70 50 57 60 24 62 99]\n",
      " [52 80 17 98 43 21 55  5]\n",
      " [55 64 47 85 81 95 74 45]\n",
      " [96 88 95 65 70 84 92 93]]\n",
      "\n",
      "\n",
      "[[ 3 16 35 88]\n",
      " [10 70 50 57]\n",
      " [52 80 17 98]\n",
      " [55 64 47 85]\n",
      " [96 88 95 65]\n",
      " [ 2 33 34 92]\n",
      " [60 24 62 99]\n",
      " [43 21 55  5]\n",
      " [81 95 74 45]\n",
      " [70 84 92 93]]\n"
     ]
    }
   ],
   "source": [
    "# Stacking or Merging two array of same dimension, np.hstack takes tuple as an argument\n",
    "arr1 = np.random.randint(low=1,high=100,size=20).reshape(5,4)\n",
    "arrNew = np.hstack((arr,arr1))\n",
    "print(arrNew)\n",
    "print()\n",
    "print()\n",
    "print(np.vstack((arr,arr1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f1fafc30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2 33 34 69]\n",
      " [69 24 69 69]\n",
      " [43 21 69  5]\n",
      " [69 69 69 45]\n",
      " [69 69 69 69]]\n"
     ]
    }
   ],
   "source": [
    "# Special and boolean slicing\n",
    "print(arr1)\n",
    "arr1[[0,2,4]]\n",
    "\n",
    "# We can also assign them values at the same time (Boolean Slicing)\n",
    "arr1[arr1>50] = 69"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ec8d514",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}