Data_Analysis_with_NumPy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# NumPy\n",
        "\n",
        "NumPy (Numerical Python) is a fundamental library for scientific computing in Python. It provides support for large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays efficiently."
      ],
      "metadata": {
        "id": "H_HFRC_iJ0ZU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Key advantages of NumPy include:**\n",
        "- Performance: NumPy's array operations are implemented in C, making them much faster than Python lists\n",
        "- Memory efficiency: NumPy arrays are more compact than Python lists\n",
        "- Convenience: NumPy provides a wide range of mathematical functions and tools\n",
        "- Integration: NumPy integrates well with other scientific Python libraries"
      ],
      "metadata": {
        "id": "NKs7zkKv4c4L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importing NumPy\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "q4sGuRWRK_rQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating NumPy Arrays\n",
        "\n",
        "NumPy's main object is the homogeneous multidimensional array. Let's create some arrays:"
      ],
      "metadata": {
        "id": "T1csaS3mMazf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a basic array from a list\n",
        "arr1 = np.array([1, 2, 3, 4, 5])\n",
        "print(\"1D array:\", arr1)\n",
        "\n",
        "# Creating a 2D array (matrix)\n",
        "arr2 = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "print(\"\\n2D array:\")\n",
        "print(arr2)\n",
        "\n",
        "# Creating arrays with specific values\n",
        "zeros = np.zeros((3, 4))  # 3x4 array of zeros\n",
        "print(\"\\nArray of zeros:\")\n",
        "print(zeros)\n",
        "\n",
        "ones = np.ones((2, 3))  # 2x3 array of ones\n",
        "print(\"\\nArray of ones:\")\n",
        "print(ones)\n",
        "\n",
        "# Creating an array with a range of values\n",
        "range_arr = np.arange(0, 10, 2)  # Start, stop, step\n",
        "print(\"\\nRange array:\", range_arr)\n",
        "\n",
        "# Creating an array with evenly spaced values\n",
        "lin_space = np.linspace(0, 1, 5)  # Start, stop, number of points\n",
        "print(\"\\nLinear space array:\", lin_space)\n",
        "\n",
        "# Creating an identity matrix\n",
        "identity = np.eye(3)\n",
        "print(\"\\nIdentity matrix:\")\n",
        "print(identity)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6Hjxnh6NklAI",
        "outputId": "3986ac6a-ca67-4374-d5b4-7715b57e21a8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1D array: [1 2 3 4 5]\n",
            "\n",
            "2D array:\n",
            "[[1 2 3]\n",
            " [4 5 6]]\n",
            "\n",
            "Array of zeros:\n",
            "[[0. 0. 0. 0.]\n",
            " [0. 0. 0. 0.]\n",
            " [0. 0. 0. 0.]]\n",
            "\n",
            "Array of ones:\n",
            "[[1. 1. 1.]\n",
            " [1. 1. 1.]]\n",
            "\n",
            "Range array: [0 2 4 6 8]\n",
            "\n",
            "Linear space array: [0.   0.25 0.5  0.75 1.  ]\n",
            "\n",
            "Identity matrix:\n",
            "[[1. 0. 0.]\n",
            " [0. 1. 0.]\n",
            " [0. 0. 1.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# NumPy Array Attributes\n",
        "NumPy arrays have several attributes that provide information about their structure:\n",
        "- shape: The dimensions of the array (rows, columns)\n",
        "- ndim: The number of dimensions\n",
        "- size: The total number of elements\n",
        "- dtype: The data type of the elements"
      ],
      "metadata": {
        "id": "UBqxj2k_kilJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a sample array\n",
        "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "\n",
        "# Display array attributes\n",
        "print(\"Array:\")\n",
        "print(arr)\n",
        "print(\"\\nShape:\", arr.shape)\n",
        "print(\"Dimensions:\", arr.ndim)\n",
        "print(\"Size:\", arr.size)\n",
        "print(\"Data type:\", arr.dtype)\n",
        "\n",
        "# Arrays with different data types\n",
        "float_arr = np.array([1.0, 2.0, 3.0])\n",
        "print(\"\\nFloat array:\")\n",
        "print(float_arr)\n",
        "print(\"\\nFloat array data type:\", float_arr.dtype)\n",
        "\n",
        "complex_arr = np.array([1+2j, 3+4j])\n",
        "print(\"\\nComplex array:\")\n",
        "print(complex_arr)\n",
        "print(\"Complex array data type:\", complex_arr.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9fuxI6dTkgUI",
        "outputId": "45f71781-8c4a-41af-e4dd-95c73d3a5ec4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Array:\n",
            "[[1 2 3]\n",
            " [4 5 6]]\n",
            "\n",
            "Shape: (2, 3)\n",
            "Dimensions: 2\n",
            "Size: 6\n",
            "Data type: int64\n",
            "\n",
            "Float array:\n",
            "[1. 2. 3.]\n",
            "\n",
            "Float array data type: float64\n",
            "\n",
            "Complex array:\n",
            "[1.+2.j 3.+4.j]\n",
            "Complex array data type: complex128\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Indexing and Slicing NumPy Arrays\n",
        "NumPy provides powerful indexing and slicing capabilities for accessing and modifying array elements:\n",
        "- Individual elements can be accessed using indices\n",
        "- Subarrays can be extracted using slicing\n",
        "- Boolean indexing can be used to select elements based on conditions"
      ],
      "metadata": {
        "id": "T7cAQE5YkPP9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a 2D array\n",
        "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
        "print(\"Original array:\")\n",
        "print(arr)\n",
        "\n",
        "# Indexing\n",
        "print(\"\\nElement at position (1,2):\", arr[1, 2])  # Row 1, Column 2\n",
        "\n",
        "# Slicing\n",
        "print(\"\\nFirst two rows:\")\n",
        "print(arr[0:2])\n",
        "\n",
        "print(\"\\nAll rows, columns 1 to 3:\")\n",
        "print(arr[:, 1:3])\n",
        "\n",
        "# Fancy indexing\n",
        "print(\"\\nFirst and third rows:\")\n",
        "print(arr[[0, 2]])\n",
        "\n",
        "# Boolean indexing\n",
        "print(\"\\nElements greater than 6:\")\n",
        "print(arr[arr > 6])\n",
        "\n",
        "# Reshaping the array\n",
        "reshaped = arr.reshape((2, 6))  # Reshape to 2x6 array\n",
        "print(\"\\nReshaped array (2x6):\")\n",
        "print(reshaped)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jQHRWtDfkIvx",
        "outputId": "c6580e86-5c43-4a06-ea1e-aff794c46823"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original array:\n",
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n",
            "\n",
            "Element at position (1,2): 7\n",
            "\n",
            "First two rows:\n",
            "[[1 2 3 4]\n",
            " [5 6 7 8]]\n",
            "\n",
            "All rows, columns 1 to 3:\n",
            "[[ 2  3]\n",
            " [ 6  7]\n",
            " [10 11]]\n",
            "\n",
            "First and third rows:\n",
            "[[ 1  2  3  4]\n",
            " [ 9 10 11 12]]\n",
            "\n",
            "Elements greater than 6:\n",
            "[ 7  8  9 10 11 12]\n",
            "\n",
            "Reshaped array (2x6):\n",
            "[[ 1  2  3  4  5  6]\n",
            " [ 7  8  9 10 11 12]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Basic Array Operations\n",
        "\n",
        "NumPy provides a wide range of operations that can be performed on arrays:\n",
        "- Arithmetic operations (addition, subtraction, multiplication, division)\n",
        "- Element-wise operations\n",
        "- Matrix operations\n",
        "- Comparison operations"
      ],
      "metadata": {
        "id": "arqGIWIhkZ34"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create two arrays\n",
        "a = np.array([1, 2, 3])\n",
        "b = np.array([4, 5, 6])\n",
        "\n",
        "# Arithmetic operations\n",
        "print(\"a + b =\", a + b)  # Addition\n",
        "print(\"a - b =\", a - b)  # Subtraction\n",
        "print(\"a * b =\", a * b)  # Element-wise multiplication\n",
        "print(\"a / b =\", a / b)  # Element-wise division\n",
        "\n",
        "# Matrix multiplication\n",
        "a_2d = np.array([[1, 2], [3, 4]])\n",
        "b_2d = np.array([[5, 6], [7, 8]])\n",
        "print(\"\\nMatrix product (a_2d @ b_2d):\")\n",
        "print(a_2d @ b_2d)  # or np.matmul(a_2d, b_2d)\n",
        "\n",
        "# Comparison operations\n",
        "print(\"\\nComparison (a < b):\", a < b)\n",
        "print(\"All elements in a < b?\", np.all(a < b))\n",
        "print(\"Any element in a > 2?\", np.any(a > 2))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4Y2T3nfMkXLm",
        "outputId": "21836a44-dd7e-44ae-9d65-df647be5c2f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a + b = [5 7 9]\n",
            "a - b = [-3 -3 -3]\n",
            "a * b = [ 4 10 18]\n",
            "a / b = [0.25 0.4  0.5 ]\n",
            "\n",
            "Matrix product (a_2d @ b_2d):\n",
            "[[19 22]\n",
            " [43 50]]\n",
            "\n",
            "Comparison (a < b): [ True  True  True]\n",
            "All elements in a < b? True\n",
            "Any element in a > 2? True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Broadcasting\n",
        "\n",
        "Broadcasting is a powerful mechanism that allows NumPy to work with arrays of different shapes during arithmetic operations. The smaller array is \"broadcast\" to match the shape of the larger array."
      ],
      "metadata": {
        "id": "87oJuwyxj_qM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Broadcasting rules:\n",
        "- If arrays don't have the same rank (number of dimensions), prepend the shape of the lower-rank array with 1s until both shapes have the same length\n",
        "- If the shape of the arrays does not match in any dimension, expand the array with shape 1 in that dimension to match the other array\n",
        "- If in any dimension the sizes disagree and neither is 1, raise an error"
      ],
      "metadata": {
        "id": "wyqHP0gr6zsj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create arrays with different shapes\n",
        "a = np.array([[1, 2, 3], [4, 5, 6]])  # 2x3 array\n",
        "b = np.array([10, 20, 30])  # 1D array with 3 elements\n",
        "\n",
        "# Broadcasting\n",
        "print(\"Array a:\")\n",
        "print(a)\n",
        "print(\"\\nArray b:\", b)\n",
        "print(\"\\na + b (broadcasting):\")\n",
        "print(a + b)  # b is broadcast to shape (2,3)\n",
        "\n",
        "# Another broadcasting example\n",
        "c = np.array([[1], [2]])  # 2x1 array\n",
        "print(\"\\nArray c:\")\n",
        "print(c)\n",
        "print(\"\\na + c (broadcasting):\")\n",
        "print(a + c)  # c is broadcast to shape (2,3)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZuOlgI4zj8wW",
        "outputId": "012a1fe9-1dfa-4e26-daf3-809c1f8f549e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Array a:\n",
            "[[1 2 3]\n",
            " [4 5 6]]\n",
            "\n",
            "Array b: [10 20 30]\n",
            "\n",
            "a + b (broadcasting):\n",
            "[[11 22 33]\n",
            " [14 25 36]]\n",
            "\n",
            "Array c:\n",
            "[[1]\n",
            " [2]]\n",
            "\n",
            "a + c (broadcasting):\n",
            "[[2 3 4]\n",
            " [6 7 8]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Mathematical Functions in NumPy\n",
        "NumPy provides a comprehensive set of mathematical functions that operate element-wise on arrays:\n",
        "- Trigonometric functions (sin, cos, tan)\n",
        "- Exponential and logarithmic functions\n",
        "- Rounding functions (floor, ceil, round)\n",
        "- And many more"
      ],
      "metadata": {
        "id": "cCf-LkzJ66p1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create an array\n",
        "a = np.array([0, 30, 45, 60, 90])\n",
        "a_rad = np.radians(a)  # Convert to radians\n",
        "\n",
        "# Trigonometric functions\n",
        "print(\"Array (degrees):\", a)\n",
        "print(\"Array (radians):\", a_rad)\n",
        "print(\"\\nSine:\", np.sin(a_rad))\n",
        "print(\"Cosine:\", np.cos(a_rad))\n",
        "\n",
        "# Exponential and logarithmic functions\n",
        "b = np.array([1, 2, 3, 4])\n",
        "print(\"\\nArray b:\", b)\n",
        "print(\"Exponential (e^x):\", np.exp(b))\n",
        "print(\"Natural logarithm (ln):\", np.log(b))\n",
        "print(\"Base-10 logarithm:\", np.log10(b))\n",
        "\n",
        "# Rounding functions\n",
        "c = np.array([1.2, 3.7, 5.5, -2.8])\n",
        "print(\"\\nArray c:\", c)\n",
        "print(\"Rounded:\", np.round(c))\n",
        "print(\"Ceiling:\", np.ceil(c))\n",
        "print(\"Floor:\", np.floor(c))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PKsP5hqK8Hmh",
        "outputId": "3ba386c9-c7b0-4d2d-ec0c-8f76bd315317"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Array (degrees): [ 0 30 45 60 90]\n",
            "Array (radians): [0.         0.52359878 0.78539816 1.04719755 1.57079633]\n",
            "\n",
            "Sine: [0.         0.5        0.70710678 0.8660254  1.        ]\n",
            "Cosine: [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01\n",
            " 6.12323400e-17]\n",
            "\n",
            "Array b: [1 2 3 4]\n",
            "Exponential (e^x): [ 2.71828183  7.3890561  20.08553692 54.59815003]\n",
            "Natural logarithm (ln): [0.         0.69314718 1.09861229 1.38629436]\n",
            "Base-10 logarithm: [0.         0.30103    0.47712125 0.60205999]\n",
            "\n",
            "Array c: [ 1.2  3.7  5.5 -2.8]\n",
            "Rounded: [ 1.  4.  6. -3.]\n",
            "Ceiling: [ 2.  4.  6. -2.]\n",
            "Floor: [ 1.  3.  5. -3.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Statistical Functions in NumPy\n",
        "NumPy provides various functions for statistical analysis of arrays:\n",
        "- Measures of central tendency (mean, median, mode)\n",
        "- Measures of dispersion (variance, standard deviation)\n",
        "- Min, max, and percentiles\n",
        "- Correlation and covariance"
      ],
      "metadata": {
        "id": "JOwWw_008RLX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a sample array\n",
        "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n",
        "print(\"Array:\", arr)\n",
        "\n",
        "# Basic statistics\n",
        "print(\"\\nMean:\", np.mean(arr))\n",
        "print(\"Median:\", np.median(arr))\n",
        "print(\"Standard deviation:\", np.std(arr))\n",
        "print(\"Variance:\", np.var(arr))\n",
        "print(\"Min:\", np.min(arr))\n",
        "print(\"Max:\", np.max(arr))\n",
        "print(\"Sum:\", np.sum(arr))\n",
        "\n",
        "# Working with 2D arrays\n",
        "arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
        "print(\"\\n2D Array:\")\n",
        "print(arr_2d)\n",
        "print(\"\\nColumn means:\", np.mean(arr_2d, axis=0))\n",
        "print(\"Row means:\", np.mean(arr_2d, axis=1))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fwA-svRX8ZMI",
        "outputId": "e72bef78-55a5-4847-ed11-ae423a300e53"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Array: [ 1  2  3  4  5  6  7  8  9 10]\n",
            "\n",
            "Mean: 5.5\n",
            "Median: 5.5\n",
            "Standard deviation: 2.8722813232690143\n",
            "Variance: 8.25\n",
            "Min: 1\n",
            "Max: 10\n",
            "Sum: 55\n",
            "\n",
            "2D Array:\n",
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "\n",
            "Column means: [4. 5. 6.]\n",
            "Row means: [2. 5. 8.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Linear Algebra with NumPy\n",
        "NumPy provides a module called linalg that includes various functions for linear algebra operations:\n",
        "- Matrix and vector products\n",
        "- Decompositions\n",
        "- Eigenvalues and eigenvectors\n",
        "- Norms and other matrix operations"
      ],
      "metadata": {
        "id": "9J_n0kcq8hpe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create matrices\n",
        "A = np.array([[1, 2], [3, 4]])\n",
        "B = np.array([[5, 6], [7, 8]])\n",
        "print(\"Matrix A:\")\n",
        "print(A)\n",
        "print(\"\\nMatrix B:\")\n",
        "print(B)\n",
        "\n",
        "# Matrix operations\n",
        "print(\"\\nMatrix multiplication (A @ B):\")\n",
        "print(np.matmul(A, B))  # or A @ B\n",
        "\n",
        "# Matrix determinant\n",
        "print(\"\\nDeterminant of A:\", np.linalg.det(A))\n",
        "\n",
        "# Matrix inverse\n",
        "print(\"\\nInverse of A:\")\n",
        "print(np.linalg.inv(A))\n",
        "\n",
        "# Eigenvalues and eigenvectors\n",
        "eigenvalues, eigenvectors = np.linalg.eig(A)\n",
        "print(\"\\nEigenvalues of A:\", eigenvalues)\n",
        "print(\"Eigenvectors of A:\")\n",
        "print(eigenvectors)\n",
        "\n",
        "# Solving linear system Ax = b\n",
        "b = np.array([1, 2])\n",
        "x = np.linalg.solve(A, b)\n",
        "print(\"\\nSolution to Ax = b:\", x)\n",
        "print(\"Verification A @ x =\", A @ x)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kRPHFWEL8pHn",
        "outputId": "63c3e738-516b-4f7e-e6f0-44777986a372"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Matrix A:\n",
            "[[1 2]\n",
            " [3 4]]\n",
            "\n",
            "Matrix B:\n",
            "[[5 6]\n",
            " [7 8]]\n",
            "\n",
            "Matrix multiplication (A @ B):\n",
            "[[19 22]\n",
            " [43 50]]\n",
            "\n",
            "Determinant of A: -2.0000000000000004\n",
            "\n",
            "Inverse of A:\n",
            "[[-2.   1. ]\n",
            " [ 1.5 -0.5]]\n",
            "\n",
            "Eigenvalues of A: [-0.37228132  5.37228132]\n",
            "Eigenvectors of A:\n",
            "[[-0.82456484 -0.41597356]\n",
            " [ 0.56576746 -0.90937671]]\n",
            "\n",
            "Solution to Ax = b: [0.  0.5]\n",
            "Verification A @ x = [1. 2.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Random Number Generation in NumPy\n",
        "NumPy has a comprehensive random module (numpy.random) for generating random numbers with various distributions."
      ],
      "metadata": {
        "id": "_HK-6qeb9FFg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Random number generation is essential for:\n",
        "Simulations\n",
        "Bootstrapping and resampling\n",
        "Initializing weights in machine learning models\n",
        "Generating synthetic data"
      ],
      "metadata": {
        "id": "0zbUiNpO9Fei"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Set a seed for reproducibility\n",
        "np.random.seed(42)\n",
        "\n",
        "# Generate random numbers from a uniform distribution [0, 1)\n",
        "uniform = np.random.rand(5)\n",
        "print(\"Uniform random numbers:\", uniform)\n",
        "\n",
        "# Generate random integers\n",
        "integers = np.random.randint(1, 100, 5)  # 5 random integers between 1 and 100\n",
        "print(\"\\nRandom integers:\", integers)\n",
        "\n",
        "# Generate random numbers from a normal distribution\n",
        "normal = np.random.normal(loc=0, scale=1, size=5)  # mean=0, std=1\n",
        "print(\"\\nNormal distribution samples:\", normal)\n",
        "\n",
        "# Random shuffling\n",
        "arr = np.arange(10)\n",
        "np.random.shuffle(arr)\n",
        "print(\"\\nShuffled array:\", arr)\n",
        "\n",
        "# Random sample from an array\n",
        "sample = np.random.choice(arr, size=5, replace=False)\n",
        "print(\"\\nRandom sample without replacement:\", sample)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bcWIVpbf9QEk",
        "outputId": "a5494b68-7e18-4acf-977c-aceb4ea6ead1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Uniform random numbers: [0.37454012 0.95071431 0.73199394 0.59865848 0.15601864]\n",
            "\n",
            "Random integers: [83 87 75 75 88]\n",
            "\n",
            "Normal distribution samples: [-0.88523035 -0.41218848 -0.4826188   0.16416482  0.23309524]\n",
            "\n",
            "Shuffled array: [5 2 7 6 8 9 3 0 4 1]\n",
            "\n",
            "Random sample without replacement: [2 9 8 4 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Example: Data Analysis with NumPy\n",
        "\n",
        "Let's demonstrate how NumPy can be used for a simple data analysis task. We'll generate synthetic data for heights (in cm) of 1000 people and perform some basic analysis:"
      ],
      "metadata": {
        "id": "wvP26GpVjtYg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Set seed for reproducibility\n",
        "np.random.seed(0)\n",
        "\n",
        "# Generate height data for 1000 people (normal distribution with mean=170cm, std=7cm)\n",
        "heights = np.random.normal(170, 7, 1000)\n",
        "\n",
        "# Basic statistics\n",
        "print(\"Height Statistics:\")\n",
        "print(f\"Mean: {np.mean(heights):.2f} cm\")\n",
        "print(f\"Median: {np.median(heights):.2f} cm\")\n",
        "print(f\"Minimum: {np.min(heights):.2f} cm\")\n",
        "print(f\"Maximum: {np.max(heights):.2f} cm\")\n",
        "print(f\"Standard Deviation: {np.std(heights):.2f} cm\")\n",
        "\n",
        "# Percentiles\n",
        "percentiles = np.percentile(heights, [25, 50, 75])\n",
        "print(f\"\\n25th Percentile: {percentiles[0]:.2f} cm\")\n",
        "print(f\"50th Percentile: {percentiles[1]:.2f} cm (same as median)\")\n",
        "print(f\"75th Percentile: {percentiles[2]:.2f} cm\")\n",
        "\n",
        "# Count people in different height ranges\n",
        "short = np.sum(heights < 160)\n",
        "medium = np.sum((heights >= 160) & (heights < 180))\n",
        "tall = np.sum(heights >= 180)\n",
        "\n",
        "print(f\"\\nHeight Distribution:\")\n",
        "print(f\"Short (<160cm): {short} people ({short/10:.1f}%)\")\n",
        "print(f\"Medium (160-180cm): {medium} people ({medium/10:.1f}%)\")\n",
        "print(f\"Tall (>180cm): {tall} people ({tall/10:.1f}%)\")\n",
        "\n",
        "# Normalize the heights (z-score)\n",
        "normalized_heights = (heights - np.mean(heights)) / np.std(heights)\n",
        "print(f\"\\nNormalized Heights (first 5):\")\n",
        "print(normalized_heights[:5])\n",
        "print(f\"Mean of normalized heights: {np.mean(normalized_heights):.10f}\")\n",
        "print(f\"Std of normalized heights: {np.std(normalized_heights):.10f}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "99nz9f3dMnsL",
        "outputId": "e45a6ba4-663d-4ce1-ad00-5c13c12a5dd6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Height Statistics:\n",
            "Mean: 169.68 cm\n",
            "Median: 169.59 cm\n",
            "Minimum: 148.68 cm\n",
            "Maximum: 189.32 cm\n",
            "Standard Deviation: 6.91 cm\n",
            "\n",
            "25th Percentile: 165.11 cm\n",
            "50th Percentile: 169.59 cm (same as median)\n",
            "75th Percentile: 174.25 cm\n",
            "\n",
            "Height Distribution:\n",
            "Short (<160cm): 78 people (7.8%)\n",
            "Medium (160-180cm): 850 people (85.0%)\n",
            "Tall (>180cm): 72 people (7.2%)\n",
            "\n",
            "Normalized Heights (first 5):\n",
            "[1.83307829 0.4512654  1.0374471  2.31618349 1.93794371]\n",
            "Mean of normalized heights: 0.0000000000\n",
            "Std of normalized heights: 1.0000000000\n"
          ]
        }
      ]
    }
  ]
}