Day21 - Numpy Fundamental.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **NumPy Fundamentals (Part-1)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy, which stands for \"Numerical Python,\" is a fundamental Python library for scientific and numerical computing. It provides support for arrays (including multi-dimensional arrays) and a wide range of mathematical functions to operate on these arrays. NumPy is a crucial library in the Python scientific computing ecosystem and is often used in conjunction with other libraries like SciPy, Matplotlib, and pandas for various data analysis and scientific computing tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy is an essential tool for data scientists, engineers, and researchers working on numerical and scientific computing tasks in Python due to its efficiency, flexibility, and extensive mathematical capabilities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some key features and aspects of NumPy:\n",
    "\n",
    "1. Arrays: NumPy's primary data structure is the ndarray (n-dimensional array). These arrays are similar to Python lists but are more efficient for numerical operations because they allow you to perform element-wise operations and take advantage of low-level optimizations.\n",
    "\n",
    "2. Efficiency: NumPy is implemented in C and Fortran, making it highly efficient for numerical computations. It also provides tools to interface with libraries written in these languages.\n",
    "\n",
    "3. Mathematical Functions: NumPy includes a wide range of mathematical functions for performing operations on arrays, such as addition, subtraction, multiplication, division, and more advanced operations like matrix multiplication, Fourier transforms, and linear algebra operations.\n",
    "\n",
    "4. Broadcasting: NumPy allows you to perform operations on arrays of different shapes and sizes through a feature called broadcasting, which automatically aligns dimensions and performs operations element-wise.\n",
    "\n",
    "5. Random Number Generation: NumPy provides functions for generating random numbers and random data, which is useful for tasks like simulations and statistical analysis.\n",
    "\n",
    "6. Integration with Other Libraries: NumPy is often used in conjunction with libraries like SciPy for scientific computing, Matplotlib for data visualization, and pandas for data manipulation and analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy Arrays Vs Python Sequences\n",
    "\n",
    "- NumPy arrays have a fixed size at creation, unlike Python lists (which can grow dynamically). Changing the size of an ndarray will create a new array and delete the original.\n",
    "\n",
    "- The elements in a NumPy array are all required to be of the same data type, and thus will be the same size in memory.\n",
    "\n",
    "- NumPy arrays facilitate advanced mathematical and other types of operations on large numbers of data. Typically, such operations are executed more efficiently and with less code than is possible using Python’s built-in sequences.\n",
    "\n",
    "- A growing plethora of scientific and mathematical Python-based packages are using NumPy arrays; though these typically support Python-sequence input, they convert such input to NumPy arrays prior to processing, and they often output NumPy arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **How To Create NumPy Arrays**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **np.array**:\n",
    "   - `np.array` is used to create NumPy arrays, which can be one-dimensional, two-dimensional, or multi-dimensional.\n",
    "   - You need to import NumPy with `import numpy as np` before using it.\n",
    "   - You can create arrays from Python lists or nested lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "# np.array\n",
    "\n",
    "import numpy as np  # we have to first import the numpy\n",
    "\n",
    "a = np.array([1,2,3])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **2D and 3D Arrays**:\n",
    "   - NumPy allows you to create multi-dimensional arrays. You demonstrated 2D and 3D arrays using nested lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "# 2D\n",
    "n = np.array([[1,2,3],[4,5,6]])\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2]\n",
      "  [3 4]]\n",
      "\n",
      " [[5 6]\n",
      "  [7 8]]]\n"
     ]
    }
   ],
   "source": [
    "# 3d\n",
    "c = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. **dtype**:\n",
    "   - You can specify the data type of the elements in a NumPy array using the `dtype` parameter.\n",
    "   - In your example, you created arrays with `dtype=float` and `dtype=int` to explicitly set the data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dtype\n",
    "np.array([1,2,3],dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1,2,3],dtype=int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. **np.arange**:\n",
    "   - `np.arange` is used to create a range of values within a specified interval.\n",
    "   - It generates an array of evenly spaced values, similar to Python's `range` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.arange\n",
    "np.arange(1,11,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. **Reshaping Arrays**:\n",
    "   - You can reshape an array using the `reshape` method. This changes the dimensions of the array while maintaining the total number of elements.\n",
    "   - In your example, you used `reshape` to create a 4D array from a 1D array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[ 0,  1],\n",
       "         [ 2,  3]],\n",
       "\n",
       "        [[ 4,  5],\n",
       "         [ 6,  7]]],\n",
       "\n",
       "\n",
       "       [[[ 8,  9],\n",
       "         [10, 11]],\n",
       "\n",
       "        [[12, 13],\n",
       "         [14, 15]]]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# with reshape\n",
    "np.arange(16).reshape(2,2,2,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. **np.ones**:\n",
    "   - `np.ones` creates an array filled with ones.\n",
    "   - You specify the shape of the array as a tuple. For example, `np.ones((3,4))` creates a 3x4 array filled with ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.ones \n",
    "np.ones((3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. **np.zeros**:\n",
    "   - `np.zeros` creates an array filled with zeros.\n",
    "   - Similar to `np.ones`, you specify the shape of the array as a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#np.zeros\n",
    "np.zeros((3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. **np.random**:\n",
    "   - `np.random.random` generates random numbers between 0 and 1 in a specified shape.\n",
    "   - It's useful for generating random data for simulations or experiments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.56431434, 0.09281216, 0.52283734, 0.34159087],\n",
       "       [0.3840281 , 0.07649243, 0.09074241, 0.4599812 ],\n",
       "       [0.09965102, 0.6279051 , 0.54948164, 0.29137218]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.random\n",
    "np.random.random((3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. **np.linspace**:\n",
    "   - `np.linspace` generates evenly spaced values over a specified range.\n",
    "   - You specify the start, end, and the number of values you want. In your example, you used `dtype=int` to ensure integer values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-10,  -8,  -6,  -4,  -2,   1,   3,   5,   7,  10])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.linspace\n",
    "np.linspace(-10,10,10,dtype=int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. **np.identity**:\n",
    "    - `np.identity` creates an identity matrix, which is a square matrix with ones on the diagonal and zeros elsewhere.\n",
    "    - You specify the size of the identity matrix as a single integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.identity\n",
    "np.identity(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These NumPy functions are essential tools for working with numerical data in Python. They provide the foundation for many scientific and data analysis tasks, making it easier to perform calculations and manipulate data efficiently."
   ]
  }
 ],
 "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
}