9_1 Numpy Basic .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d621639f-9e9b-4d22-a032-e1a2eed20680",
   "metadata": {},
   "outputs": [],
   "source": [
    "Consider the below code to answer further questions:\n",
    "import numpy as np\n",
    "list_ = [ ‘1’ , ’2’ , ‘3’ , ‘4’ , ‘5’ ]\n",
    "array_list = np.array(object = list_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69f07381-03e9-4127-ab5b-8392c6688435",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q1. Is there any difference in the data type of variables list_ and array_list? If there is then write a code\n",
    "to print the data types of both the variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b20f932b-5fe6-468d-8df4-08ae01191795",
   "metadata": {},
   "outputs": [],
   "source": [
    "Yes, there is a difference in the data type of the list_ variable and the array_list variable. The list_ variable is a Python list, while the array_list variable is a numpy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b9fd4065-b093-4a47-8be6-89d214af5d4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data type of list_: <class 'list'>\n",
      "Data type of array_list: <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "list_ = ['1','2','3','4','5']\n",
    "array_list = np.array (object = list_)\n",
    "\n",
    "print(\"Data type of list_:\",type(list_))\n",
    "print(\"Data type of array_list:\",type(array_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc4560b1-f3f6-4449-8ab3-8697a8f23882",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q2. Write a code to print the data type of each and every element of both the variables list_ and\n",
    "arra_list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5e1fb764-8b20-473b-81a2-f2c2fa892698",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Types of element in list_:str\n",
      "Types of element in list_:str\n",
      "Types of element in list_:str\n",
      "Types of element in list_:str\n",
      "Types of element in list_:str\n",
      "Type of element in array_list:str_\n",
      "Type of element in array_list:str_\n",
      "Type of element in array_list:str_\n",
      "Type of element in array_list:str_\n",
      "Type of element in array_list:str_\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Your existing code\n",
    "list_ = ['1', '2', '3', '4', '5']\n",
    "array_list = np.array(object=list_)\n",
    "\n",
    "#print data types\n",
    "for item in list_:\n",
    "    print(f\"Types of element in list_:{type(item).__name__}\")\n",
    "    \n",
    "for item in array_list:\n",
    "    print(f\"Type of element in array_list:{type(item).__name__}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2da9b55b-fbd5-4961-a12f-dcebf1ad93e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q3. Considering the following changes in the variable, array_list:\n",
    "array_list = np.array(object = list_, dtype = int)\n",
    "Will there be any difference in the data type of the elements present in both the variables, list_ and\n",
    "arra_list? If so then print the data types of each and every element present in both the variables, list_\n",
    "and arra_list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3db80029-1a60-49f5-a8db-403889b7b75b",
   "metadata": {},
   "outputs": [],
   "source": [
    "Lists:\n",
    "A list is an inbuilt collection of items that can contain elements of multiple data types (numeric, character, logical values, etc.).\n",
    "Lists are ordered and support negative indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8bc9b06d-828e-44ff-bfd5-f0d56ded0a8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "sample_list = [1, \"Yash\", ['a', 'e']]\n",
    "print(type(sample_list))  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a2e4f6a-bac0-4a62-92af-71e0c6f1c640",
   "metadata": {},
   "outputs": [],
   "source": [
    "Arrays:\n",
    "An array is a vector containing homogeneous elements (belonging to the same data type).\n",
    "Elements in arrays are allocated contiguous memory locations.\n",
    "Unlike lists, arrays require all elements to be of the same data type (typically numeric types like integers or floats)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fab9ce00-148c-41a4-a1b0-a71dbbc78bc2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'array.array'>\n"
     ]
    }
   ],
   "source": [
    "import array as arr\n",
    "a = arr.array('i', [1, 2, 3])\n",
    "print(type(a))  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3dc8548-be3b-4db3-8a16-7b48c0d4a1e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "Difference Between List and Array:\n",
    "Lists can consist of elements belonging to different data types, while arrays only consist of elements belonging to the same data type.\n",
    "Lists do not require explicit module import for declaration, whereas arrays need the array module.\n",
    "Lists can handle arithmetic operations directly, but arrays are more memory-efficient due to their contiguous memory allocation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b9d7f0f7-e113-42e5-8a42-8052baee7203",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data types in list_:\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "\n",
      "Data types in array_list:\n",
      "<class 'numpy.int64'>\n",
      "<class 'numpy.int64'>\n",
      "<class 'numpy.int64'>\n",
      "<class 'numpy.int64'>\n",
      "<class 'numpy.int64'>\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Assuming list_ is defined somewhere before\n",
    "# list_ = [1, 2, 3, 4, 5]\n",
    "\n",
    "array_list = np.array(object=list_, dtype=int)\n",
    "\n",
    "# Print data types of elements in list_\n",
    "print(\"Data types in list_:\")\n",
    "for item in list_:\n",
    "    print(type(item))\n",
    "\n",
    "# Print data types of elements in array_list\n",
    "print(\"\\nData types in array_list:\")\n",
    "for item in array_list:\n",
    "    print(type(item))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96645783-290e-496d-97a7-853a4a81cb86",
   "metadata": {},
   "outputs": [],
   "source": [
    "Consider the below code to answer further questions:\n",
    "import numpy as np\n",
    "num_list = [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ]\n",
    "num_array = np.array(object = num_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb351ea9-c1e7-4c83-aabd-6be9848b4889",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q4. Write a code to find the following characteristics of variable, num_array:\n",
    "(i) shape\n",
    "(ii) size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ac9abec-19c3-4b7d-b98b-b3e80334ea21",
   "metadata": {},
   "outputs": [],
   "source": [
    "1.Shape: The shape of an array refers to its dimensions. For a 2D array, it represents the number of rows and columns. You can obtain the shape using the .shape attribute. In this case, num_array.shape will give you the shape\n",
    "2.Size: The size of an array is the total number of elements in it. You can get the size using the .size attribute. For num_array, num_array.size will give you the size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f105548f-9b76-461a-bcd0-fc55c9d4a31e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of num_array:(2, 3)\n",
      "Size of num_array:6\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "#your existing code to create num_array\n",
    "num_list = [[1,2,3],[4,5,6]]\n",
    "num_array = np.array(object = num_list)\n",
    "\n",
    "#Characteristics\n",
    "shape = num_array.shape\n",
    "size = num_array.size\n",
    "print(f\"Shape of num_array:{shape}\")\n",
    "print(f\"Size of num_array:{size}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34def51f-8e14-4743-bb15-4fd3208a32e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q5. Write a code to create numpy array of 3*3 matrix containing zeros only, using a numpy array\n",
    "creation function.\n",
    "[Hint: The size of the array will be 9 and the shape will be (3,3).]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7a91282f-cf7c-4ffc-8ad3-2153abe396a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "#create a 3*3 array of zeros\n",
    "zero_matrix = np.zeros((3,3))\n",
    "print(zero_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84414905-0b12-4449-b25e-5282ddef73fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q6. Create an identity matrix of shape (5,5) using numpy functions?\n",
    "[Hint: An identity matrix is a matrix containing 1 diagonally and other elements will be 0.]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "00efd82a-f3b6-4d14-9d7a-0e680ec9f9c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[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"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "#Create a 5*5 identity matrix\n",
    "identity_matrix = np.identity(5)\n",
    "print(identity_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e663e5cf-c8b7-4505-9d81-9c89fdd8399a",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}