Assignment 22.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "240a4b8f",
   "metadata": {},
   "source": [
    "# Assignment 22"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1161ae2e",
   "metadata": {},
   "source": [
    "## 1. What are the benefits of the built-in array package, if any?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aab14c5b",
   "metadata": {},
   "source": [
    "__Ans:__ Arrays represent multiple data items of the same type using a single name. In arrays, the elements can be accessed randomly by using the index number. Arrays allocate memory in contiguous memory locations for all its elements. Hence, there is no chance of extra memory being allocated in case of arrays. This avoids memory overflow or shortage of memory in arrays.\n",
    "\n",
    "Lists and NumPy Arrays usually are much better alternatives. That’s also the reason why rarely people knows Python has a built-in Array type.\n",
    "\n",
    "However, when something is restricted, it must bring some benefits. That is the so-call “trade-off”. In this case, Python Array will have a smaller size than Python List. This is demonstrated below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "663dd719",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "800040"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from array import array\n",
    "list_large = list(range(0, 100000))\n",
    "arr_large = array('I', list_large)\n",
    "\n",
    "arr_large.__sizeof__()  #Size comes out to be 400064\n",
    "list_large.__sizeof__() #Size comes out to be 900088"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "379dfb47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array('i', [1, 2, 3, 4])\n"
     ]
    }
   ],
   "source": [
    "#Using Built in Array\n",
    "import array as built_in\n",
    "array1 = built_in.array('i', [1, 2])\n",
    "array1.append(3)\n",
    "array1.append(4)\n",
    "print(array1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7da97e0",
   "metadata": {},
   "source": [
    "## 2. What are some of the array package's limitations?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe11fc3f",
   "metadata": {},
   "source": [
    "__Ans:__ The number of elements to be stored in an array should be known in advance. An array is a static structure (which means the array is of fixed size). Once declared the size of the array cannot be modified. The memory which is allocated to it cannot be increased or decreased.\n",
    "\n",
    "Insertion and deletion are quite difficult in an array as the elements are stored in consecutive memory locations and the shifting operation is costly.\n",
    "\n",
    "Allocating more memory than the requirement leads to wastage of memory space and less allocation of memory also leads to a problem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6570805",
   "metadata": {},
   "source": [
    "## 3. Describe the main differences between the array and numpy packages."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "564cd475",
   "metadata": {},
   "source": [
    "__Ans:__ The array package doesn't provide any help with numerical calculation with the items insdie it in number form while NumPy give you a wide variety of numerical operations.\n",
    "\n",
    "An array is a single dimensional entity which hold the numerical data, while numpy can have more than 1 dimension.\n",
    "\n",
    "In case of array, item can be accessed by its index position and it is easy task while in numpy item is accessed by its column and row index, which makes it slightly time taking. Same goes with appending operation.\n",
    "\n",
    "In case of array we do not form a tabular structure, while in numpy it forms a tabular structure"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3376ad39",
   "metadata": {},
   "source": [
    "## 4. Explain the distinctions between the empty, ones, and zeros functions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76429332",
   "metadata": {},
   "source": [
    "__Ans:__ The distinctions between the `empty`, `ones`, and `zero` functions are as follows :\n",
    "\n",
    "- `Empty function:` An empty function is a function that does not contain any statement within its body. If you try to write a function definition without any statement in python ,it will return an error. To avoid this, we use pass statement. pass is a special statement in Python that does nothing. It only works as a dummy statement.\n",
    "- `Ones:` This function returns a new array of given shape and data type, where the element’s value is 1.\n",
    "- `Zeros:` This function returns a new array of given shape and data type, where the element’s value is 0."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "125203ef",
   "metadata": {},
   "source": [
    "## 5. In the fromfunction function, which is used to construct new arrays, what is the role of the callable argument?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99ab90f2",
   "metadata": {},
   "source": [
    "__Ans:__ Its function is to execute the function over each coordinate and the resulting array. The function is called with N parameters, where N is the rank of shape. Each parameter represents the coordinates of the array varying along a specific axis."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8385aec8",
   "metadata": {},
   "source": [
    "## 6. What happens when a numpy array is combined with a single-value operand (a scalar, such as an int or a floating-point value) through addition, as in the expression A + n?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d100e45",
   "metadata": {},
   "source": [
    "__Ans:__ If any scaler value such as integer is added to the numpy array then all the elements inside the array will add that value in it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49e2ee5d",
   "metadata": {},
   "source": [
    "## 7. Can array-to-scalar operations use combined operation-assign operators (such as += or *=)? What is the outcome?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec3fe7a0",
   "metadata": {},
   "source": [
    "__Ans:__ It will carry out provided operation on all elements of array."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7862624",
   "metadata": {},
   "source": [
    "## 8. Does a numpy array contain fixed-length strings? What happens if you allocate a longer string to one of these arrays?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68bd6226",
   "metadata": {},
   "source": [
    "__Ans:__ Yes, it is possible that we can include a string of fixed length in numpy array. The dtype of any numpy array containing string values is the maximum length of any string present in the array.Once set, it will only be able to store new string having length not more than the maximum length at the time of the creation. If we try to reassign some another string value having length greater than the maximum length of the existing elements, it simply discards all the values beyond the maximum length accept upto those values which are under the limit."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1cb69d3",
   "metadata": {},
   "source": [
    "## 9. What happens when you combine two numpy arrays using an operation like addition (+) or multiplication (*)? What are the conditions for combining two numpy arrays?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "604ab7dd",
   "metadata": {},
   "source": [
    "__Ans:__ It will simply add or multiply element to element at same position."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ace75429",
   "metadata": {},
   "source": [
    "## 10. What is the best way to use a Boolean array to mask another array?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d3f82f7",
   "metadata": {},
   "source": [
    "__Ans:__ The best way to use a Boolean array to mask another array is by Using masked_where of numpy package"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fb0ac86",
   "metadata": {},
   "source": [
    "## 11. What are three different ways to get the standard deviation of a wide collection of data using both standard Python and its packages? Sort the three of them by how quickly they execute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "29a1782c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Standard Deviation of the sample is 17.56337730114064 \n"
     ]
    }
   ],
   "source": [
    "import numpy as np #for declaring an array\n",
    " \n",
    "def mean(data):\n",
    "  n = len(data)\n",
    "  mean = sum(data) / n\n",
    "  return mean\n",
    " \n",
    "def variance(data):\n",
    "  n = len(data)\n",
    "  mean = sum(data) / n\n",
    "  deviations = [(x - mean) ** 2 for x in data]\n",
    "  variance = sum(deviations) / n\n",
    "  return variance\n",
    " \n",
    "def stdev(data):\n",
    "  import math\n",
    "  var = variance(data)\n",
    "  std_dev = math.sqrt(var)\n",
    "  return std_dev\n",
    " \n",
    "data = np.array([7,5,4,9,12,54])\n",
    " \n",
    "print(\"Standard Deviation of the sample is % s \"% (stdev(data)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "168d1292",
   "metadata": {},
   "source": [
    "__Ans:__ np.std and math package can be used individually."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9313ae88",
   "metadata": {},
   "source": [
    "## 12. What is the dimensionality of a Boolean mask-generated array?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d08da4a4",
   "metadata": {},
   "source": [
    "__Ans:__ It will have same dimensionality as input array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e38f0abc",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}