1_python_numpy_basics/8_numpy_part_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Table of numpy function/method used \n",
    "\n",
    "| Syntax      | function/method | Description     |\n",
    "| :----:      |    :----:       |   :----:        |\n",
    "| array()     |   function      |used to initialize  array of different dimentions | \n",
    "| arange(start,end,interval)    |  function       |returns an array with evenly spaced elements as per the interval.|\n",
    "| linspace(start,end,nos_of_elements)    |  function         |returns an array with evenly spaced elements as per the interval.|\n",
    "| logspace(start,end,nos_of_elements)      |  function         |return numbers spaced evenly on a log scale.|\n",
    "| zeros(n,datatype)      |  function         |returns a new array of given shape and type, with 0's.|\n",
    "| ones(n,datatype)      |  function         |returns a new array of given shape and type, with 1's.|\n",
    "| dtype       |  method         |returns the data type of the array|\n",
    "| view()      |  method         |used for shallow copying|\n",
    "| copy()      |  method         |used for deep copying|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# INDEX\n",
    "\n",
    "### - Types of Array\n",
    "### -  numpy\n",
    "> 1. Importing library\n",
    "> 2. NumPy Array Indexing\n",
    "> 3. NumPy Array Slicing\n",
    "> 4. NumPy Data Types\n",
    "> 5. copy v/s view\n",
    "> 6. Ways to create array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Types of Arrays \n",
    "\n",
    "\n",
    "**Single Dimentional Arrays** - These type of array represent only one row or one column of elements\n",
    "\n",
    "**Multi-Dimentional Arrays** - These type of array represent more than one row and more than\n",
    "one column of elements\n",
    "\n",
    "**NOTE** - Code under section of *Types of Arrays* should not be run as it will give error. Here main motive is to make one understand how different arrays exist.\n",
    "We will understand correct way to implement in further in course"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  Single Dimentional Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "marks = array( [50,60,70,80] )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multi-Dimentional Arrays\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nmarks1 = array([[50,60,70,80],\\n                [60,62,56,70],\\n                [71,59,80,68]])\\n'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2- Dimentional Arrays\n",
    "\n",
    "# An array that has 1-D arrays as its elements is called a 2-D array.\n",
    "\n",
    "marks1 = array([[50,60,70,80],\n",
    "                [60,62,56,70],\n",
    "                [71,59,80,68]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nmarks2 = array([[[1, 2, 3], \\n                 [4, 5, 6]],\\n                [[1, 2, 3], \\n                 [4, 5, 6]]])\\n'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3- Dimentional Arrays\n",
    "# An array that has 2-D arrays (matrices) as its elements is called 3-D array.\n",
    "\n",
    "marks2 = array([[[1, 2, 3], \n",
    "                 [4, 5, 6]],\n",
    "                [[1, 2, 3], \n",
    "                 [4, 5, 6]]])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# numpy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. numpy is a package that contains several classes, functions, variables etc. to deal with scientific calculations in Python.\n",
    "2. numpy is useful to create and also process single and multi-dimensional arrays.\n",
    "3. In addition, numpy contains a large library of mathematical functions like linear algebra functions and Fourier transforms.\n",
    "4. The array object in NumPy is called ndarray, it provides a lot of supporting functions that make working with ndarray very easy.\n",
    "5. Arrays are very frequently used in data science, where speed and resources are very important.\n",
    "\n",
    "- To get complete help on numpy, the reader can refer to the following link at scipy.org:\n",
    "\n",
    "  **http://docs.scipy.org/doc/numpy/reference/**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing the library "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30 40 50]\n"
     ]
    }
   ],
   "source": [
    "# to use numpy in out program we should first import numpy using 'import' keyword \n",
    "\n",
    "import numpy\n",
    "\n",
    "# create single dimensional array using numpy \n",
    "\n",
    "arr = numpy.array([10,20,30,40,50])\n",
    "print(arr)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30 40 50]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "\"\"\"\n",
    "Here we are using 'np' as reference to numpy. \n",
    "So whenever we need to type numpy we simply use np insted\n",
    "This makes typing easy\n",
    "\"\"\"\n",
    "\n",
    "arr1 = np.array([10,20,30,40,50])\n",
    "print(arr1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30 40 50]\n"
     ]
    }
   ],
   "source": [
    "from numpy import * \n",
    "\n",
    "\"\"\"\n",
    "This will import everything(* means all) from numpy package \n",
    "Now, we dont need to use any name to refer the objects \n",
    "or functions in our program\n",
    "\"\"\"\n",
    "\n",
    "arr2 = array([10,20,30,40,50])\n",
    "print(arr2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Array Indexing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Array indexing is the same as accessing an array element.\n",
    "\n",
    "2. You can access an array element by referring to its index number.\n",
    "\n",
    "3. The indexes in NumPy arrays start with 0, meaning that the first element has index 0, and the second has index 1 etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78\n",
      "25\n",
      "84\n",
      "99\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr3 = np.array([78,25,84,99,520])\n",
    "\n",
    "for i in range(4):\n",
    "    print(arr3[i])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr4 = np.array([[1,2,3,4,5], \n",
    "                 [6,7,8,9,10]])\n",
    "\n",
    "# to print last element of senond row \n",
    "\n",
    "print(arr4[1][4]) # represent 1st row and 4th column of arr4\n",
    "#or\n",
    "print(arr4[1,-1])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr = np.array([\n",
    "                 [[1, 2, 3], \n",
    "                 [4, 5, 6]], \n",
    "    \n",
    "                [[7, 8, 9], \n",
    "                 [10, 11, 12]]])\n",
    "\n",
    "print(arr[1, 1, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Array Slicing\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Slicing refers to extracting a range of elements from the array. The format of slicing operation is given as:\n",
    "\n",
    "2. We pass slice instead of index like this:   \n",
    ">arrayname[start:end:step]       \n",
    "                        \n",
    "   this will print elements starting from index 'start'  upto  'end-1' \n",
    "\n",
    "3. If we don't pass start its considered 0\n",
    "\n",
    "4. If we don't pass end its considered length of array in that dimension\n",
    "\n",
    "5. If we don't pass step its considered 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE -** \n",
    "- When negative number i is used for 'start', it should be taken as n+i. \n",
    "- When negative number j is used for  'stop', it should be taken as n+j. \n",
    "- When negative number is used for 'stepsize', the stepping goes towards \n",
    "  smaller indexes.\n",
    "- n is number of elements in an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  6  7  8  9 10 11]\n"
     ]
    }
   ],
   "source": [
    "from numpy import * \n",
    "\n",
    "a = arange(5,12)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 6  8 10]\n"
     ]
    }
   ],
   "source": [
    "a1 = a[1::2]\n",
    "print(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10  9  8]\n"
     ]
    }
   ],
   "source": [
    "a2 = a[-2:2:-1]\n",
    "print(a2)\n",
    "\n",
    "# if here step = 1 \n",
    "# empty array will be printed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ***Question ??***\n",
    "\n",
    "If,\n",
    "a3 = a[ : : ]\n",
    "\n",
    "1. What will be a3 when print ? \n",
    "2. How to reverse the order of array a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing 2-D Arrays\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7 8 9]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "b = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])\n",
    "\n",
    "print(b[1, 1:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 8]\n"
     ]
    }
   ],
   "source": [
    "# From both elements, return index 2:\n",
    "import numpy as np\n",
    "\n",
    "b1 = b[0:2, 2]\n",
    "\n",
    "print(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3 4]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "#From both elements, slice index 1 to index 4 (not included), \n",
    "#this will return a 2-D array:\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "b2 = b[0:2, 1:4]\n",
    "print(b2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Data Types\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Data Types in Python**\n",
    "\n",
    "1. By default Python have these data types:\n",
    "\n",
    "> - strings - used to represent text data, the text is given under quote marks. e.g. \"ABCD\"  \n",
    "> - integer - used to represent integer numbers. e.g. -1, -2, -3  \n",
    "> - float - used to represent real numbers. e.g. 1.2, 42.42  \n",
    "> - boolean - used to represent True or False.  \n",
    "> - complex - used to represent complex numbers. e.g. 1.0 + 2.0j, 1.5 + 2.5j  \n",
    "\n",
    "2. Data Types in NumPy  \n",
    "   NumPy has some extra data types, and refer to data types with one character,    like i for integers, u for unsigned integers etc.\n",
    "\n",
    "3. Below is a list of all data types in NumPy and the characters used to        represent them.\n",
    "\n",
    "> - i - integer  \n",
    "> - b - boolean  \n",
    "> - u - unsigned integer  \n",
    "> - f - float  \n",
    "> - c - complex float  \n",
    "> - m - timedelta  \n",
    "> - M - datetime  \n",
    "> - O - object  \n",
    "> - S - string  \n",
    "> - U - unicode string  \n",
    "> - V - fixed chunk of memory for other type ( void )  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Checking the Data Type of an Array  \n",
    "The NumPy array object has a property called **dtype** that returns the data type of the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<U1\n",
      "int32\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr5 = np.array(['A', 'B', 'C'])\n",
    "print(arr5.dtype)\n",
    "\n",
    "arr6 = np.array([1, 2, 3, 4])\n",
    "print(arr6.dtype)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# copy v/s view\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "memory loaction of array c: 2334466356768\n",
      "memory loaction of array c: 2334466356768\n"
     ]
    }
   ],
   "source": [
    "from numpy import * \n",
    "\n",
    "c = array([1,2,3,4,5])\n",
    "d = c \n",
    "\n",
    "print('memory loaction of array c:', id(c))\n",
    "print('memory loaction of array c:', id(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. This is a simple assignment that does not make any new copy of the array 'c'. It means, 'd' is not a new array and memory is not allocated to 'd'. \n",
    "2. Also, elements from 'c' are not copied into 'd' since there is no memory for 'd'. \n",
    "3. It means the names 'a' and 'b' are referencing same array. \n",
    "   This is called 'aliasing'. \n",
    "\n",
    "4. 'Aliasing' is not 'copying'. Aliasing means giving another name to the existing bbject. Hence, any modifications to the alias object will reflect in the existing object and vice versa. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c =  [10  2  3  4  5]\n",
      "d =  [10  2  3  4  5]\n"
     ]
    }
   ],
   "source": [
    "d[0] = 10   # modifying d\n",
    "\n",
    "# after modification\n",
    "print(\"c = \", c)\n",
    "print(\"d = \", d)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Viewing an array\n",
    "\n",
    "1. We can create another array that is same as an existing array. \n",
    "   This is done by the **view()** method. \n",
    "2. This method creates a copy of an existing array such that the new array will also contain the same elements found in the existing array. \n",
    "3. The original array and the newly created arrays will share *different memory locations.* \n",
    "4. If the newly created array is modified, the original array will also be modified since the elements in both the arrays will be like mirror images. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "memory loaction of array e: 2334489084992\n",
      "memory loaction of array f: 2334489084112\n",
      "e =  [20  2  3  4  5]\n",
      "f =  [20  2  3  4  5]\n"
     ]
    }
   ],
   "source": [
    "# code for viewing an array.\n",
    "\n",
    "import numpy as np \n",
    "\n",
    "e = np.arange(1,6)\n",
    "f = e.view()      # ‘shallow copying’\n",
    "\n",
    "\n",
    "print('memory loaction of array e:',id(e))\n",
    "print('memory loaction of array f:',id(f))\n",
    "\n",
    "\n",
    "f[0] = 20\n",
    "\n",
    "print(\"e = \", e)\n",
    "print(\"f = \", f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Copying an array \n",
    "\n",
    "1. Suppose we want both the arrays to be independent and modifying one array should not affect another array we should go for *‘deep copying’.*\n",
    "\n",
    "2. This is done with the help of **copy()** method. This method makes a complete copy of an existing array and its elements.\n",
    "\n",
    "3. When the newly created array is modified, it will not affect the existing array or vice versa. There will not be any connection between the elements of the two arrays.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "memory loaction of array g: 2334489086992\n",
      "memory loaction of array h: 2334489085872\n",
      "g =  [0 1 2 3 4 5 6 7 8 9]\n",
      "h =  [25  1  2  3  4  5  6  7  8  9]\n"
     ]
    }
   ],
   "source": [
    "# code for copying an array.\n",
    "\n",
    "import numpy as np \n",
    " \n",
    "g = np.arange(10)\n",
    "h = g.copy()      # 'deep copy'\n",
    "\n",
    "print('memory loaction of array g:',id(g))\n",
    "print('memory loaction of array h:',id(h))\n",
    "\n",
    "\n",
    "h[0] = 25\n",
    "\n",
    "print(\"g = \",g)\n",
    "print(\"h = \",h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ways to create array "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Creating arrays in numpy can be done in several ways. Some of the important ways are:\n",
    "> 1. using array() function \n",
    "> 2. using linspace() function\n",
    "> 3. using logspace() function\n",
    "> 4. using arange() funtion \n",
    "> 5. using zeros() and ones() function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Creating Arrays using linspace**\n",
    "\n",
    "1. The linspace function is used to create an array with evenly spaced points between a starting point and ending point. The form of the linspace() function is:\n",
    "\n",
    "> linspace(start, stop, n)\n",
    "\n",
    "2. start' represents the starting element and 'stop' represents the ending element. 'n' is an integer that represents the number of parts the elements should be divided. If 'n' is omitted, then it is taken as 50. Let's take one example to understand this.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  5. 10. 15. 20.]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "\n",
    "i= np.linspace(0, 20,5)\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Creating Arrays using logspace**\n",
    "\n",
    "1. The logspace() function is similar to linspace(). \n",
    "2. The linspace() function produces the evenly spaced points. \n",
    "   Similarly, logspace() produces evenly spaced points on a logarithmically spaced scale. \n",
    "3. The logspace() function is used in the following format: \n",
    "> logspace(start, stop, n)\n",
    "\n",
    "4. The logspace() function starts at a value which is 10 to the power of 'start' and ends at a value which is 10 to the power of 'stop'. \n",
    "5. If 'n' is not specified, then its value is taken as 50. \n",
    "\n",
    "For example, if we write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   10.            56.23413252   316.22776602  1778.27941004\n",
      " 10000.        ]\n"
     ]
    }
   ],
   "source": [
    "j = logspace(1, 4, 5)\n",
    "print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Creating Arrays using zeros() and ones() function**\n",
    "\n",
    "1. We can use zeros() function to create an array with all elements as 0 \n",
    "\n",
    "2. Similarly, We can use ones() function to create an array with all elements as 1 \n",
    "\n",
    "*syntax -*\n",
    "\n",
    "> zeros(n,datatype)  \n",
    "> ones(n,datatype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0]\n",
      "[1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "k = zeros(3,int)\n",
    "l = ones(5 , float)\n",
    "\n",
    "print(k)\n",
    "print(l)"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}