Numpy_Ben.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kWO9lq_QYGUj"
   },
   "source": [
    "In this project you going to implement some basics of numpy that you learnt till now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EXiryNSTYGUt"
   },
   "source": [
    "# Numpy\n",
    "Numpy is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays. If you are already familiar with MATLAB, you might find this tutorial useful to get started with Numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I33Wuo8VYGUt"
   },
   "source": [
    "## 1. Numpy Array\n",
    "A numpy array is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension.\n",
    "\n",
    "We can initialize numpy arrays from nested Python lists, and access elements using square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "aTlr-EW1YGUu"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "(3,)\n",
      "1\n",
      "2\n",
      "3\n",
      "[5 2 3]\n",
      "(2, 3)\n",
      "1 2 4\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Q1. Create a rank 1 array with elements 1,2,3 (1 marks)\n",
    "\n",
    "## start code here\n",
    "a = np.array([1,2,3])\n",
    "\n",
    "# Q2. print its type and shape (1 marks)\n",
    "\n",
    "## Start code here\n",
    "print(type(a))\n",
    "print(a.shape)\n",
    "# Q3. Print each of its element individually (1 marks)\n",
    "\n",
    "## Start code here\n",
    "#print(*a)\n",
    "for i in range(len(a)):\n",
    "    print(a[i])\n",
    "\n",
    "# Q4. Change element of the array at zero index with 5  (1 marks)\n",
    "\n",
    "## Start code here\n",
    "a[0]=5\n",
    "\n",
    "# print new array\n",
    "print(a)\n",
    "\n",
    "# Q5. Create a rank 2 array like [[1,2,3],[4,5,6]]  (1 marks)\n",
    "\n",
    "## Start code here\n",
    "b =np.array([[1,2,3],[4,5,6]])\n",
    "\n",
    "# Q6. print its shape (1 marks)\n",
    "print(b.shape)\n",
    "\n",
    "print(b[0, 0], b[0, 1], b[1, 0])   # Prints \"1 2 4\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cdDAg9PMYGUv"
   },
   "source": [
    "Numpy also provides many functions to create arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "yXS2R-ROYGUv"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n",
      "[[1. 1.]]\n",
      "[[7 7]\n",
      " [7 7]]\n",
      "[[1. 0.]\n",
      " [0. 1.]]\n",
      "[[36  2]\n",
      " [27 42]]\n"
     ]
    }
   ],
   "source": [
    "# Q1. Create an array of all zeros with shape (2,2) (1 marks)\n",
    "## Start code here\n",
    "a = np.zeros((2,2))\n",
    "print(a)             \n",
    "\n",
    "# Q2. Create an array of all ones with shape (1,2) (1 marks)\n",
    "## Start code here\n",
    "b = np.ones((1,2))\n",
    "print(b)            \n",
    "\n",
    "# Q3. Create a constant array with shape (2,2) and value 7 (1 marks)\n",
    "## Start code here\n",
    "c = np.full((2,2),7)  \n",
    "print(c)              \n",
    "\n",
    "# Q4. Create a 2x2 identity matrix (1 marks)\n",
    "## Start code here\n",
    "d = np.identity(2)\n",
    "print(d)              \n",
    "\n",
    "# Q5. Create an (2,2) array filled with random values (1 marks)\n",
    "## Start code here\n",
    "e = np.random.randint(45,size=(2,2))\n",
    "print(e)                     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jHdDlCqkYGUw"
   },
   "source": [
    "You can read about other methods of array creation in the documentation in the link below.\n",
    "\n",
    "http://docs.scipy.org/doc/numpy/user/basics.creation.html#arrays-creation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jcQMlmwhYGUw"
   },
   "source": [
    "## 2. Array indexing\n",
    "Numpy offers several ways to index into arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "17KpUbICYGUx"
   },
   "source": [
    "**a) Slicing:** Similar to Python lists, numpy arrays can be sliced. Since arrays may be multidimensional, you must specify a slice for each dimension of the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "8ecBheCtYGUx"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3]\n",
      " [6 7]]\n",
      "2\n",
      "77\n"
     ]
    }
   ],
   "source": [
    "# Q1. Create the following rank 2 array with shape (3, 4) and values as given below (1 mark)\n",
    "# [[ 1  2  3  4]\n",
    "#  [ 5  6  7  8]\n",
    "#  [ 9 10 11 12]]\n",
    "\n",
    "# Start code here\n",
    "a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])\n",
    "\n",
    "# Q2. Use slicing to pull out the subarray consisting of the first 2 rows\n",
    "# and columns 1 and 2; b is the following array of shape (2, 2): (1 mark)\n",
    "\n",
    "# Start code here\n",
    "b = a[:2,1:3]\n",
    "print(b)\n",
    "\n",
    "# A slice of an array is a view into the same data, so modifying it\n",
    "# will modify the original array.\n",
    "print(a[0, 1])   # Prints \"2\"\n",
    "b[0, 0] = 77     # b[0, 0] is the same piece of data as a[0, 1]\n",
    "print(a[0, 1])   # Prints \"77\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NnMJUA1jYGUy"
   },
   "source": [
    "You can also mix integer indexing with slice indexing. However, doing so will yield an array of lower rank than the original array. Note that this is quite different from the way that MATLAB handles array slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "U13hQSXyYGUy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6 7 8]\n",
      "[5 6 7 8] (4,)\n",
      "[5 6 7 8] (4,)\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "list indices must be integers or slices, not tuple",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [41]\u001b[0m, in \u001b[0;36m<cell line: 31>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     27\u001b[0m col_r1 \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(a[\u001b[38;5;241m0\u001b[39m:\u001b[38;5;241m1\u001b[39m])\n\u001b[0;32m     29\u001b[0m \u001b[38;5;66;03m# Q5. Create Rank 2 view of the second column of a (1 marks)\u001b[39;00m\n\u001b[0;32m     30\u001b[0m \u001b[38;5;66;03m# Start code here\u001b[39;00m\n\u001b[1;32m---> 31\u001b[0m col_r2 \u001b[38;5;241m=\u001b[39mnp\u001b[38;5;241m.\u001b[39marray(\u001b[43ma\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m)\n\u001b[0;32m     33\u001b[0m \u001b[38;5;28mprint\u001b[39m(col_r1, col_r1\u001b[38;5;241m.\u001b[39mshape) \n\u001b[0;32m     34\u001b[0m \u001b[38;5;28mprint\u001b[39m(col_r2, col_r2\u001b[38;5;241m.\u001b[39mshape)\n",
      "\u001b[1;31mTypeError\u001b[0m: list indices must be integers or slices, not tuple"
     ]
    }
   ],
   "source": [
    "# Q1. Create the following rank 2 array with shape (3, 4) value as given below (1 marks)\n",
    "# [[ 1  2  3  4]\n",
    "#  [ 5  6  7  8]\n",
    "#  [ 9 10 11 12]]\n",
    "\n",
    "# Start code here\n",
    "a = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]\n",
    "\n",
    "# Two ways of accessing the data in the middle row of the array.\n",
    "# Mixing integer indexing with slices yields an array of lower rank,\n",
    "# while using only slices yields an array of the same rank as the original array:\n",
    "\n",
    "# Q2. Create Rank 1 view of the second row of a (1 marks)\n",
    "# Start code here\n",
    "row_r1 = np.array(a[1])\n",
    "print(row_r1)\n",
    "# Q3. # Create Rank 2 view of the second row of a (1 marks)\n",
    "# Start code here\n",
    "row_r2 = np.array(a[1])\n",
    "\n",
    "print(row_r1, row_r1.shape)\n",
    "print(row_r2, row_r2.shape)  \n",
    "# We can make the same distinction when accessing columns of an array:\n",
    "\n",
    "# Q4. Create Rank 1 view of the second column of a (1 marks)\n",
    "# Start code here\n",
    "col_r1 = np.array(a[0:1])\n",
    "\n",
    "# Q5. Create Rank 2 view of the second column of a (1 marks)\n",
    "# Start code here\n",
    "col_r2 =np.array(a[:,1])\n",
    "\n",
    "print(col_r1, col_r1.shape) \n",
    "print(col_r2, col_r2.shape)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VnjIDN1NYGUy"
   },
   "source": [
    "**b) Integer array indexing:** When you index into numpy arrays using slicing, the resulting array view will always be a subarray of the original array. In contrast, integer array indexing allows you to construct arbitrary arrays using the data from another array. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Y_WCzV_gYGUz"
   },
   "outputs": [],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "\n",
    "# An example of integer array indexing.\n",
    "# Using the array \"a\" created above and integer indexing\n",
    "\n",
    "# Q1. print an array  that should have shape (3,) and should print \"[1 4 5]\" when printed (1 marks)\n",
    "## Start code\n",
    "\n",
    "\n",
    "# The method of integer array indexing that you implemented is equivalent to this:\n",
    "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))  # Prints \"[1 4 5]\"\n",
    "\n",
    "# When using integer array indexing, you can reuse the same\n",
    "# element from the source array:\n",
    "\n",
    "# Q2. Print the array that prints \"[2 2]\" when printed (1 marks)\n",
    "\n",
    "## Start code \n",
    "\n",
    "# Equivalent to the previous integer array indexing example\n",
    "print(np.array([a[0, 1], a[0, 1]]))  # Prints \"[2 2]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pB8sEDriYGUz"
   },
   "source": [
    "One useful trick with integer array indexing is selecting or mutating one element from each row of a matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "id": "YjP5jiX4YGUz"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "1\n",
      "6\n",
      "7\n",
      "11\n",
      "11\n",
      "16\n",
      "17\n",
      "21\n",
      "[[11  2  3]\n",
      " [ 4  5 16]\n",
      " [17  8  9]\n",
      " [10 21 12]]\n"
     ]
    }
   ],
   "source": [
    "# Create a new array from which we will select elements\n",
    "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "print(a) \n",
    "\n",
    "\n",
    "# Create an array of indices\n",
    "b = np.array([0, 2, 0, 1])\n",
    "\n",
    "# Q1. Select one element from each row of a using the indices in b and print it (1 marks)\n",
    "## Start code\n",
    "for i in range(len(b)):\n",
    "    print(a[i][b[i]])\n",
    "\n",
    "\n",
    "# Q2. Mutate one element from each row of a using the indices in b by adding 10 to it and print it (1 marks)\n",
    "## Start code\n",
    "for i in range(len(b)):\n",
    "    a[i][b[i]]+=10\n",
    "    print(a[i][b[i]])\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ND-YB3YgYGU0"
   },
   "source": [
    "**c) Boolean array indexing:** Boolean array indexing lets you pick out arbitrary elements of an array. Frequently this type of indexing is used to select the elements of an array that satisfy some condition. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Cq0FP5ASYGU0"
   },
   "outputs": [],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "\n",
    "# Q1. Find the elements of a that are bigger than 2 using boolean indexing (1 marks)\n",
    "## Start code\n",
    "bool_idx = \n",
    "\n",
    "print(bool_idx)     \n",
    "\n",
    "# We use boolean array indexing to construct a rank 1 array\n",
    "# consisting of the elements of a corresponding to the True values\n",
    "# of bool_idx\n",
    "print(a[bool_idx])  \n",
    "\n",
    "# We can do all of the above in a single concise statement:\n",
    "print(a[a > 2])    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LoVFyp4pYGU0"
   },
   "source": [
    "For brevity we have left out a lot of details about numpy array indexing; if you want to know more you should read the documentation from the given link.\n",
    "http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PE6jqN1QYGU1"
   },
   "source": [
    "## 3. Datatypes\n",
    "Every numpy array is a grid of elements of the same type. Numpy provides a large set of numeric datatypes that you can use to construct arrays. Numpy tries to guess a datatype when you create an array, but functions that construct arrays usually also include an optional argument to explicitly specify the datatype. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CzBvQg-MYGU1"
   },
   "outputs": [],
   "source": [
    "x = np.array([1, 2])   # Let numpy choose the datatype\n",
    "print(x.dtype)         # Prints \"int64\"\n",
    "\n",
    "x = np.array([1.0, 2.0])   # Let numpy choose the datatype\n",
    "print(x.dtype)             # Prints \"float64\"\n",
    "\n",
    "x = np.array([1, 2], dtype=np.int64)   # Force a particular datatype\n",
    "print(x.dtype)                         # Prints \"int64\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ev9YogmCYGU1"
   },
   "source": [
    "You can read all about numpy datatypes in the documentation from the given link.\n",
    "http://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IPCzLqmHYGU3"
   },
   "source": [
    "## 4. Array math\n",
    "Basic mathematical functions operate elementwise on arrays, and are available both as operator overloads and as functions in the numpy module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xG73NKFQYGU6"
   },
   "outputs": [],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "# Q1. print Elementwise sum of x and y (1 marks)\n",
    "## Start code here\n",
    "\n",
    "# Q2. print Elementwise difference of x and y (1 marks)\n",
    "## Start code here\n",
    "\n",
    "# Q3. print Elementwise product of x and y (1 marks)\n",
    "## Start code here\n",
    "\n",
    "# Q4. print Elementwise divison of x and y (1 marks)\n",
    "## Start code here\n",
    "\n",
    "# Q5. print Elementwise square root of x (1 marks)\n",
    "## Start code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7_Oa4fqhYGU7"
   },
   "source": [
    "Note that unlike MATLAB, * is elementwise multiplication, not matrix multiplication. We instead use the dot function to compute inner products of vectors, to multiply a vector by a matrix, and to multiply matrices. dot is available both as a function in the numpy module and as an instance method of array objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "izX8RS5sYGU8"
   },
   "outputs": [],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "y = np.array([[5,6],[7,8]])\n",
    "\n",
    "v = np.array([9,10])\n",
    "w = np.array([11, 12])\n",
    "\n",
    "# Q1. print Inner product of vectors v and w; (1 marks)\n",
    "## Start code here\n",
    "\n",
    "# Q2. print Matrix / vector product of x and v; (1 marks)\n",
    "## Start code here\n",
    "\n",
    "# Q3. print Matrix / matrix product of x and y; (1 marks)\n",
    "## Start code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MftlgfhVYGU9"
   },
   "source": [
    "Numpy provides many useful functions for performing computations on arrays; one of the most useful is sum:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "O-nKCFDSYGU-"
   },
   "outputs": [],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "\n",
    "# Q1. Compute sum of all elements and print it (1 marks)\n",
    "## Start code here\n",
    "\n",
    "# Q2. Compute sum of each column and print it (1 marks)\n",
    "## Start code here\n",
    "\n",
    "# Q3. Compute sum of each row and print it (1 marks)\n",
    "## Start code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q683270TYGVA"
   },
   "source": [
    "You can find the full list of mathematical functions provided by numpy in the documentation on the provided link.\n",
    "http://docs.scipy.org/doc/numpy/reference/routines.math.html\n",
    "\n",
    "Apart from computing mathematical functions using arrays, we frequently need to reshape or otherwise manipulate data in arrays. The simplest example of this type of operation is transposing a matrix; to transpose a matrix, simply use the T attribute of an array object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9hVBFo9jYGVA"
   },
   "outputs": [],
   "source": [
    "x = np.array([[1,2], [3,4]])\n",
    "\n",
    "# Q1. print x and its transpose (2 marks)\n",
    "## Start code here\n",
    "\n",
    "# Note that taking the transpose of a rank 1 array does nothing:\n",
    "v = np.array([1,2,3])\n",
    "\n",
    "# Q2. print v and its transpose (2 marks)\n",
    "## Start code here\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Numpy Template-checkpoint.ipynb",
   "provenance": []
  },
  "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": 1
}