NumPy Array Object Exercises.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.18.5\n"
     ]
    }
   ],
   "source": [
    "#to know the version of numpy\n",
    "import numpy as np\n",
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original list is:\n",
      "[1, 4, 5.5, 7, 8]\n",
      "1-D array\n",
      "[1.  4.  5.5 7.  8. ]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to convert a list of numeric value into a one-dimensional NumPy array.\n",
    "import numpy as np\n",
    "print(\"original list is:\")\n",
    "x=[1,4,5.5,7,8]\n",
    "print(x)\n",
    "a=np.array(x)\n",
    "print(\"1-D array\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4],\n",
       "       [ 5,  6,  7],\n",
       "       [ 8,  9, 10]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Write a NumPy program to create a 3x3 matrix with values ranging from 2 to 10.\n",
    "import numpy as np\n",
    "# a=np.random.randint(2,10,9).reshape(3,3)\n",
    "# a\n",
    "arr=np.arange(2,11).reshape(3,3)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      "after updating:\n",
      "[ 0.  0.  0.  0.  0.  0. 11.  0.  0.  0.]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to create a null vector of size 10 and update sixth value to 11\n",
    "import numpy as np\n",
    "x=np.zeros(10)\n",
    "print(x)\n",
    "x[6]=11\n",
    "print(\"after updating:\")\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35\n",
      " 36 37]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to create an array with values ranging from 12 to 38\n",
    "import numpy as np\n",
    "a=np.arange(12,38)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  5  6  7  8  9 10]\n",
      "after reversing:\n",
      "[10  9  8  7  6  5  4  3  2  1]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to reverse an array (first element becomes last).\n",
    "import numpy as np\n",
    "a=np.arange(1,11)\n",
    "print(a)\n",
    "print(\"after reversing:\")\n",
    "print(a[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before converting:\n",
      "[ 1  2  3  4  5  6  7  8  9 10]\n",
      "int32\n",
      "after converting:\n",
      "[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to convert an array to a float type.\n",
    "import numpy as np\n",
    "a=np.arange(1,11)\n",
    "print(\"before converting:\")\n",
    "print(a)\n",
    "print(a.dtype)\n",
    "a=a.astype(float)\n",
    "print(\"after converting:\")\n",
    "print(a)\n",
    "print(a.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original matrix is:\n",
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n",
      "after updating:\n",
      "[[1. 1. 1. 1.]\n",
      " [1. 0. 0. 1.]\n",
      " [1. 0. 0. 1.]\n",
      " [1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to create a 2d array with 1 on the border and 0 inside.\n",
    "import numpy as np\n",
    "arr=np.ones((4,4))\n",
    "print(\"original matrix is:\")\n",
    "print(arr)\n",
    "arr[1:-1,1:-1]=0\n",
    "print(\"after updating:\")\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "ater changing it's border:\n",
      "[[0. 0. 0. 0. 0.]\n",
      " [0. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to add a border (filled with 0's) around an existing array.\n",
    "import numpy as np\n",
    "arr=np.ones((3,3))\n",
    "print(arr)\n",
    "print(\"ater changing it's border:\")\n",
    "arr=np.pad(arr,pad_width=1,mode='constant',constant_values=0)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]]\n",
      "[[1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to create a 8x8 matrix and fill it with a checkerboard pattern.\n",
    "import numpy as np\n",
    "a=np.ones((8,8))\n",
    "print(a)\n",
    "a[1::2,::2]=1\n",
    "a[::2,1::2]=1\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "[4 5 6]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to convert a list and tuple into arrays.\n",
    "import numpy as np\n",
    "arr=[1,2,3,4]\n",
    "x=np.array(arr)\n",
    "print(x)\n",
    "arr1=(4,5,6)\n",
    "y=np.array(arr1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4 11 22 33 44]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to append values to the end of an array\n",
    "import numpy as np\n",
    "arr=[1,2,3,4]\n",
    "x=np.append(arr,([11,22],[33,44]))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "full matrix:\n",
      "[[5 5 5 5]\n",
      " [5 5 5 5]\n",
      " [5 5 5 5]\n",
      " [5 5 5 5]]\n",
      "empty matrix:\n",
      "[[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to create an empty and a full array. \n",
    "import numpy as np\n",
    "x=np.full((4,4),5)\n",
    "print(\"full matrix:\")\n",
    "print(x)\n",
    "print(\"empty matrix:\")\n",
    "y=np.empty((3,4))\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.   12.   45.21 34.   99.91]\n",
      "value in centigrade:\n",
      "[-17.77777778 -11.11111111   7.33888889   1.11111111  37.72777778]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to convert the values of Centigrade degrees into Fahrenheit degrees.\n",
    "import numpy as np\n",
    "x=np.array([0, 12, 45.21 ,34, 99.91])\n",
    "print(x)\n",
    "print(\"value in centigrade:\")\n",
    "print(5/9*x-32*5/9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[1 4 9]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x=[1,2,3]\n",
    "a=np.array(x)\n",
    "print(a)\n",
    "print(a**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.]\n",
      "[4.]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to find the real and imaginary parts of an array of complex numbers\n",
    "import numpy as np\n",
    "x=np.array([3+4j])\n",
    "print(x.real)\n",
    "print(x.imag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 9 8]\n",
      "3\n",
      "4\n",
      "int32\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to find the number of elements of an array, length of one array element in bytes\n",
    "#and total bytes consumed by the elements.\n",
    "import numpy as np\n",
    "a=np.array([5,9,8])\n",
    "print(a)\n",
    "print(len(a))\n",
    "print(a.itemsize)\n",
    "print(a.dtype)\n",
    "print(a.nbytes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 2 8 8]\n",
      "[1 3 5]\n",
      "comparing both array:\n",
      "[ True  True  True False False False]\n",
      "intersection value:\n",
      "[1 3 5]\n",
      "unique value:\n",
      "[1 2 3 5 8]\n",
      "set difference:\n",
      "[2 8]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to test whether each element of a 1-D array is also present in a second array.\n",
    "#intersection array\n",
    "#unique value\n",
    "#set difference\n",
    "import numpy as np\n",
    "a=np.array([1,3,5,2,8,8])\n",
    "b=np.array([1,3,5])\n",
    "#print(set(a)-set(b))\n",
    "print(a)\n",
    "print(b)\n",
    "print(\"comparing both array:\")\n",
    "print(np.in1d(a,b))\n",
    "print(\"intersection value:\")\n",
    "print(np.intersect1d(a,b))\n",
    "print(\"unique value:\")\n",
    "print(np.union1d(a,b))\n",
    "print(\"set difference:\")\n",
    "print(np.setdiff1d(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 5 7 8]\n",
      "[1 3 5 7]\n",
      "after appending:\n",
      "[2 5 7 8 1 3 5 7]\n",
      "[5 7]\n",
      "(aub)-(a^b)\n",
      "[1 2 3 8]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to find the set exclusive-or of two arrays. Set exclusive-or will return the sorted, unique values.\n",
    "#that are in only one (not both) of the input arrays.\n",
    "import numpy as np\n",
    "a=np.array([2,5,7,8])\n",
    "b=np.array([1,3,5,7])\n",
    "print(a)\n",
    "print(b)\n",
    "x=np.append(a,b)\n",
    "print(\"after appending:\")\n",
    "print(x)\n",
    "y=np.intersect1d(a,b)\n",
    "print(y)\n",
    "print(\"(aub)-(a^b)\")\n",
    "print(np.setdiff1d(x,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to test whether all elements in an array evaluate to True.\n",
    "#0--->False otherwise True.\n",
    "import numpy as np\n",
    "print(np.all([1,3,5,0,7]))\n",
    "print(np.all([1,5,8,9]))\n",
    "print(np.all([True,True]))\n",
    "print(np.all([False,True]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to test whether any array element along a given axis evaluates to True.\n",
    "print(np.any([1,23,5,7,0,9]))\n",
    "print(np.any([0,0,0,0,0]))\n",
    "print(np.any([1,23,43,5,6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "repeat 4 times:\n",
      "[1 2 3 1 2 3 1 2 3 1 2 3]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to construct an array by repeating.\n",
    "import numpy as np\n",
    "a=np.array([1,2,3])\n",
    "#print(list(a)*2)\n",
    "print(\"repeat 4 times:\")\n",
    "print(np.tile(a,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 3 3 3 3]\n",
      "[1 1 2 2 3 3 4 4 5 5 6 6]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to repeat elements of an array.\n",
    "import numpy as np\n",
    "a=np.repeat(3,5)\n",
    "print(a)\n",
    "b=np.array(([1,2,3],[4,5,6]))\n",
    "print(np.repeat(b,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum index is: 2\n",
      "min index is: 0\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to find the indices of the maximum and minimum values along the given axis of an array.\n",
    "import numpy as np\n",
    "x=np.array([1,6,8,4,5])\n",
    "# print(min(x))\n",
    "# print(max(x))\n",
    "print(\"maximum index is:\",np.argmax(x))\n",
    "print(\"min index is:\",np.argmin(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "#refrence i.e rough\n",
    "x=[1,2,3,4]\n",
    "print(x.index(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True False]\n",
      "[False False]\n",
      "[False  True]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program compare two given arrays. \n",
    "import numpy as np\n",
    "a=np.array([2,2])\n",
    "b=np.array([2,3])\n",
    "print(a>=b)\n",
    "print(a>b)\n",
    "print(a<b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original is:\n",
      "[[4 6]\n",
      " [2 1]]\n",
      "sort along first axis\n",
      "[[2 1]\n",
      " [4 6]]\n",
      "sort along last axis:\n",
      "[[1 2]\n",
      " [4 6]]\n"
     ]
    }
   ],
   "source": [
    "# Write a NumPy program to sort an along the first, last axis of an array.\n",
    "import numpy as np\n",
    "a=np.array([[4,6],[2,1]])\n",
    "print(\"original is:\")\n",
    "print(a)\n",
    "x=np.sort(a,axis=0)\n",
    "print(\"sort along first axis\")\n",
    "print(x)\n",
    "print(\"sort along last axis:\")\n",
    "y=np.sort(x,axis=1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[20 14  5]\n",
      " [ 2  8 32]]\n",
      "value greater than 10 are:\n",
      "[20 14 32]\n",
      "index are:\n",
      " (array([0, 0, 1], dtype=int64), array([0, 1, 2], dtype=int64))\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to get the values and indices of the elements that are bigger than 10 in a given array.\n",
    "import numpy as np\n",
    "arr=np.array(([20,14,5],[2,8,32]))\n",
    "print(arr)\n",
    "print(\"value greater than 10 are:\")\n",
    "print(arr[arr>10])\n",
    "print(\"index are:\\n\",np.nonzero(arr>10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 1 1 1]\n",
      "[0 0 0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to create an array of ones and an array of zeros. \n",
    "import numpy as np\n",
    "arr=np.ones(5,dtype=int)\n",
    "print(arr)\n",
    "a=np.zeros(7,dtype=int)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2]\n",
      " [ 3  4]\n",
      " [ 5  6]\n",
      " [ 7  8]\n",
      " [ 9 10]]\n",
      "[[1 2 4 0 3]\n",
      " [7 8 0 0 5]\n",
      " [2 8 0 7 8]\n",
      " [4 2 4 4 0]\n",
      " [3 5 8 2 3]]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to change the dimension of an array.\n",
    "import numpy as np\n",
    "x=np.arange(1,11).reshape(5,2)\n",
    "print(x)\n",
    "y=np.random.randint(0,9,size=(5,5))\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to create a contiguous flattened array\n",
    "import numpy as np\n",
    "a=np.array([[1,2,3],[2,3,4]])#.reshape(-1)\n",
    "print(np.ravel(a))\n",
    "#print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 8 4]\n",
      " [2 8 2]]\n",
      "6\n",
      "(2, 3)\n",
      "int32\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to create a 2-dimensional array of size 2 x 3\n",
    "import numpy as np\n",
    "arr=np.random.choice([2,6,8,4],size=(2,3))\n",
    "print(arr)\n",
    "print(arr.size)\n",
    "print(arr.shape)\n",
    "print(arr.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original is:\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "(2, 3)\n",
      "after changing it's shape\n",
      "[[1 4]\n",
      " [2 5]\n",
      " [3 6]]\n",
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to create a new shape to an array without changing its data.\n",
    "import numpy as np\n",
    "arr=np.arange(1,7).reshape(2,3)\n",
    "print(\"original is:\")\n",
    "print(arr)\n",
    "print(arr.shape)\n",
    "arr=arr.T\n",
    "print(\"after changing it's shape\")\n",
    "print(arr)\n",
    "print(arr.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original:\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "(2, 3)\n",
      "after changing it's dtype:\n",
      "[[1. 2. 3.]\n",
      " [4. 5. 6.]]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to change the data type of an array. \n",
    "import numpy as np\n",
    "arr=np.array([[1,2,3],[4,5,6]])\n",
    "print(\"original:\")\n",
    "print(arr)\n",
    "print(arr.shape)\n",
    "print(\"after changing it's dtype:\")\n",
    "print(arr.astype(float))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 2, 2, 2, 2],\n",
       "       [2, 2, 2, 2, 2],\n",
       "       [2, 2, 2, 2, 2]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Write a NumPy program to create a new array of 3*5, filled with 2\n",
    "import numpy as np\n",
    "arr=np.full((3,5),2)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10, 10])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write a NumPy program to create an array of 10's with the same shape and type of a given array. \n",
    "import numpy as np\n",
    "arr=np.full((1,4),10).reshape(-1)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n",
      "(3, 3)\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to create a 3-D array with ones on a diagonal and zeros elsewhere.\n",
    "a=np.identity(3)\n",
    "print(a)\n",
    "print(a.shape)\n",
    "print(a.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 0, 0, 0],\n",
       "       [0, 5, 0, 0],\n",
       "       [0, 0, 6, 0],\n",
       "       [0, 0, 0, 8]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Write a NumPy program to create a 2-D array whose diagonal equals [4, 5, 6, 8] and 0's elsewhere\n",
    "import numpy as np\n",
    "arr=np.diagflat([4,5,6,8])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  100.           141.25375446   199.5262315    281.83829313\n",
      "   398.10717055   562.34132519   794.32823472  1122.0184543\n",
      "  1584.89319246  2238.72113857  3162.27766017  4466.83592151\n",
      "  6309.5734448   8912.50938134 12589.25411794 17782.79410039\n",
      " 25118.8643151  35481.33892336 50118.72336273 70794.57843841]\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to to create a 1-D array of 20 element spaced evenly on a log scale between 2. and 5., exclusive.\n",
    "import numpy as np\n",
    "arr=np.logspace(2.,5.,20,endpoint=False)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Write a NumPy program to collapse a 3-D array into one dimension array.\n",
    "import numpy as np\n",
    "arr=np.array(([1,2,3],[4,5,6],[7,8,9])).reshape(-1)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n"
     ]
    }
   ],
   "source": [
    "#Write a NumPy program to find the 4th element of a specified array.\n",
    "import numpy as np\n",
    "arr=np.array([[1,2,3],[33,4,5]])\n",
    "x=arr.flat[3]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Write a NumPy program to convert a NumPy array to an image. Display the image\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "img_w,img_h=200,200\n",
    "data=np.zeros((img_h,img_w,3),dtype=int)\n",
    "data[100,100]=[200,200,0]\n",
    "img=Image.fromarray(data,'RGB')\n",
    "img.save('test.png')\n",
    "img.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Write a NumPy program to compute the histogram of a set of data.\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "plt.hist([1, 2, 1], bins=[0, 1, 2, 3, 5])\n",
    "plt.show()"
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}