Day22 - NumPy Attributes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **NumPy Attributes and Operations**\n",
    "\n",
    "NumPy is a popular Python library for numerical and scientific computing. It provides a wide range of functionality for working with arrays and matrices. NumPy arrays are at the core of the library, and they come with a variety of attributes and methods for performing operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Array Attributes**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "----------\n",
      "[[ 0.  1.  2.  3.]\n",
      " [ 4.  5.  6.  7.]\n",
      " [ 8.  9. 10. 11.]]\n",
      "----------\n",
      "[[[0 1]\n",
      "  [2 3]]\n",
      "\n",
      " [[4 5]\n",
      "  [6 7]]]\n"
     ]
    }
   ],
   "source": [
    "# lets assume three array\n",
    "a1 = np.arange(10,dtype=np.int32)\n",
    "\n",
    "a2 = np.arange(12,dtype=float).reshape(3,4)\n",
    "\n",
    "a3 = np.arange(8).reshape(2,2,2)\n",
    "\n",
    "print(a1)\n",
    "print('----------')\n",
    "print(a2)\n",
    "print('----------')\n",
    "print(a3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **ndim**\n",
    "\n",
    "This attribute returns the number of dimensions of a NumPy array. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a3.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* a1.ndim returns 1 because a1 is a one-dimensional array.\n",
    "* a2.ndim returns 2 because a2 is a two-dimensional array.\n",
    "* a3.ndim returns 3 because a3 is a three-dimensional array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **shape**\n",
    "\n",
    "The shape attribute returns a tuple representing the dimensions of the array. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,)\n",
      "(3, 4)\n",
      "(2, 2, 2)\n"
     ]
    }
   ],
   "source": [
    "print(a1.shape)\n",
    "print(a2.shape)\n",
    "print(a3.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* a1.shape returns (10,) because a1 is a one-dimensional array with a length of 10.\n",
    "* a2.shape returns (3, 4) because a2 is a two-dimensional array with 3 rows and 4 columns.\n",
    "* a3.shape returns (2, 2, 2) because a3 is a three-dimensional array with dimensions 2x2x2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **size**\n",
    "The size attribute returns the total number of elements in the array. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "12\n",
      "8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[[0, 1],\n",
       "        [2, 3]],\n",
       "\n",
       "       [[4, 5],\n",
       "        [6, 7]]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(a1.size)\n",
    "print(a2.size)\n",
    "print(a3.size)\n",
    "a3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* a1.size returns 10 because a1 has 10 elements.\n",
    "* a2.size returns 12 because a2 has 12 elements.\n",
    "* a3.size returns 8 because a3 has 8 elements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **itemsize**\n",
    "\n",
    "The itemsize attribute returns the size (in bytes) of each element in the array. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a3.itemsize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* a2.itemsize returns 8 because a2 is of type float64, which has 8 bytes per element.\n",
    "* a3.itemsize returns 4 because a3 is of type int32, which has 4 bytes per element."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **dtype**\n",
    "The dtype attribute returns the data type of the elements in the array. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n",
      "float64\n",
      "int32\n"
     ]
    }
   ],
   "source": [
    "print(a1.dtype)\n",
    "print(a2.dtype)\n",
    "print(a3.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* a1.dtype returns int32 because a1 is of type int32.\n",
    "* a2.dtype returns float64 because a2 is of type float64.\n",
    "* a3.dtype returns int32 because a3 is of type int32."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Changing Datatype**\n",
    "You can change the data type of an array using the astype method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 1],\n",
       "        [2, 3]],\n",
       "\n",
       "       [[4, 5],\n",
       "        [6, 7]]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# astype\n",
    "a3.astype(np.int32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Array operations**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = np.arange(12).reshape(3,4)\n",
    "a2 = np.arange(12,24).reshape(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "--------\n",
      "[[12 13 14 15]\n",
      " [16 17 18 19]\n",
      " [20 21 22 23]]\n"
     ]
    }
   ],
   "source": [
    "print(a1)\n",
    "print('--------')\n",
    "print(a2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Scalar operations**\n",
    "\n",
    "These operations involve performing mathematical operations on the entire array with a scalar value.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  3  4  5]\n",
      " [ 6  7  8  9]\n",
      " [10 11 12 13]]\n",
      "-----\n",
      "[[  0   1   4   9]\n",
      " [ 16  25  36  49]\n",
      " [ 64  81 100 121]]\n",
      "-----\n",
      "[[-5 -4 -3 -2]\n",
      " [-1  0  1  2]\n",
      " [ 3  4  5  6]]\n"
     ]
    }
   ],
   "source": [
    "# arithmatic - all arithmatic opearation works like\n",
    "print(a1 + 2)\n",
    "print('-----')\n",
    "print(a1 **2)\n",
    "print('-----')\n",
    "print(a1 - 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False,  True],\n",
       "       [False, False, False, False],\n",
       "       [False, False, False, False]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# relational -> all relational opearators work like\n",
    "a2 == 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2 > 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **vector operations**\n",
    "These operations involve performing mathematical operations between two arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[          0,           1,       16384,    14348907],\n",
       "       [          0, -1564725563,  1159987200,   442181591],\n",
       "       [          0,  1914644777, -1304428544,  -122979837]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# arithmetic\n",
    "a1 ** a2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy provides powerful tools for working with arrays efficiently, making it a valuable library for scientific and numerical computations in Python."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}