{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8edc6035",
   "metadata": {},
   "source": [
    "# Numpy\n",
    "\n",
    "## 1. Set up\n",
    "\n",
    "To install numpy run:\n",
    "\n",
    "```\n",
    "pip install numpy\n",
    "```\n",
    "\n",
    "In a terminal, or the following cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7abd6488",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: numpy in ./.venv/lib/python3.12/site-packages (2.3.4)\n"
     ]
    }
   ],
   "source": [
    "!pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "995f61ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numpy version: 2.3.4\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "print(\"Numpy version:\", np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "928d95b7",
   "metadata": {},
   "source": [
    "## 2. Creating arrays\n",
    "\n",
    "### 2.1. From lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e7f9a0b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr_1d = np.array([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1242adbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "print(arr_1d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0a18339c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(arr_1d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a342f386",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "arr_2d = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(arr_2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f21a630f",
   "metadata": {},
   "source": [
    "### 2.2. Using built-in functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "13b54184",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "zero_array = np.zeros((3,4))\n",
    "print(zero_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "abbe3efa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "const_array = np.full((3,4), 1.0)\n",
    "print(const_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02786d71",
   "metadata": {},
   "source": [
    "## 3. Array attributes\n",
    "\n",
    "For more info, check out the [array attributes](https://numpy.org/doc/stable/reference/arrays.ndarray.html#array-attributes) section of the NumPy API reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7b69f964",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const_array.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ac508dbe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const_array.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4515f5fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "96"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const_array.nbytes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7d9a44f",
   "metadata": {},
   "source": [
    "## 4. Array function & operations\n",
    "\n",
    "For more info on avalible operations and their behavior see the following in the NumPy API documentation:\n",
    "\n",
    "1. [Functions and methods overview](https://numpy.org/doc/stable/user/quickstart.html#functions-and-methods-overview) \n",
    "2. [Array methods](https://numpy.org/doc/stable/reference/arrays.ndarray.html#array-methods)\n",
    "3. [Arithmetic, matrix multiplication, and comparison operations](https://numpy.org/doc/stable/reference/arrays.ndarray.html#arithmetic-matrix-multiplication-and-comparison-operations)\n",
    "\n",
    "### 4.1. Arithmetic operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1f6dde53",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([10,20,30,40])\n",
    "b = np.array([1,2,3,4])\n",
    "c = np.array([1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "44401251",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11 22 33 44]\n"
     ]
    }
   ],
   "source": [
    "print(a + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e2330dce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9 18 27 36]\n"
     ]
    }
   ],
   "source": [
    "print(a - b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "29065808",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11 21 31 41]\n"
     ]
    }
   ],
   "source": [
    "print(a + c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ab77f3e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20 40 60 80]\n"
     ]
    }
   ],
   "source": [
    "print(a * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d7614236",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "list_a = [1,2,3]\n",
    "list_b = [4,5,6]\n",
    "\n",
    "new_array = np.array(list_a + list_b)\n",
    "print(new_array)\n",
    "print(type(new_array))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea5d335a",
   "metadata": {},
   "source": [
    "### 4.2. Statistical methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "28dea160",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.0\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7e42549d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fd275a1",
   "metadata": {},
   "source": [
    "### 4.3. Methods on axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "7dd98080",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "3.5\n"
     ]
    }
   ],
   "source": [
    "print(arr_2d)\n",
    "print(np.mean(arr_2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "6f8e0e30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "print(arr_2d.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "9de62504",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.5 3.5 4.5]\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(arr_2d, axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bf9acc2",
   "metadata": {},
   "source": [
    "### 4.4. Shape manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "29174954",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(12)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "e4682367",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4  5]\n",
      " [ 6  7  8  9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "new_arr = arr.reshape(2,6)\n",
    "print(new_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "a3934909",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 20 30 40]\n",
      " [ 1  2  3  4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([10,20,30,40])\n",
    "b = np.array([1,2,3,4])\n",
    "\n",
    "vstacked = np.vstack([a, b])\n",
    "print(vstacked)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a81fb4f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30 40  1  2  3  4]\n"
     ]
    }
   ],
   "source": [
    "hstack = np.hstack([a, b])\n",
    "print(hstack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "2831f367",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10  1]\n",
      " [20  2]\n",
      " [30  3]\n",
      " [40  4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([\n",
    "    [10],\n",
    "    [20],\n",
    "    [30],\n",
    "    [40]\n",
    "])\n",
    "\n",
    "b = np.array([\n",
    "    [1],\n",
    "    [2],\n",
    "    [3],\n",
    "    [4]\n",
    "])\n",
    "\n",
    "hstack = np.hstack([a, b])\n",
    "print(hstack)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54658a8f",
   "metadata": {},
   "source": [
    "### 4.5. Conversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "1800c4ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "7cdb5aeb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float32\n"
     ]
    }
   ],
   "source": [
    "b_float = b.astype(np.float32)\n",
    "print(b_float.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "62428632",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.]\n",
      " [2.]\n",
      " [3.]\n",
      " [4.]]\n"
     ]
    }
   ],
   "source": [
    "print(b_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0d494d7",
   "metadata": {},
   "source": [
    "## 5. Selecting data\n",
    "\n",
    "For more info, see the [Indexing, slicing and iterating](https://numpy.org/doc/stable/user/quickstart.html#quickstart-indexing-slicing-and-iterating) section in the NumPy User Guide."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bda39c",
   "metadata": {},
   "source": [
    "### 5.1. Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "e16960e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([10,20,30,40])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "58088e31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(a[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "de833fdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 20 30 40]\n",
      " [ 1  2  3  4]]\n"
     ]
    }
   ],
   "source": [
    "print(vstacked)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "1977a044",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n"
     ]
    }
   ],
   "source": [
    "print(vstacked[0][-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "eb05d805",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n"
     ]
    }
   ],
   "source": [
    "print(vstacked[0, -1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "bf63341c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n"
     ]
    }
   ],
   "source": [
    "python_lol = [[10, 20, 30, 40],\n",
    "              [1,  2,  3,  4]]\n",
    "\n",
    "print(python_lol[0][-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43f41dbd",
   "metadata": {},
   "source": [
    "### 5.2. Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "a23d457f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 20 30 40]\n",
      " [ 1  2  3  4]]\n"
     ]
    }
   ],
   "source": [
    "print(vstacked)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "6a7ce38e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30 40]\n"
     ]
    }
   ],
   "source": [
    "print(vstacked[0, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "fc05abc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10  1]\n"
     ]
    }
   ],
   "source": [
    "print(vstacked[:, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "0bd90ed9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20 30]\n"
     ]
    }
   ],
   "source": [
    "print(vstacked[0, 1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "b8424757",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[20 30]\n",
      " [ 2  3]]\n"
     ]
    }
   ],
   "source": [
    "print(vstacked[:, 1:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ed435b7",
   "metadata": {},
   "source": [
    "### 5.3 Masking & Filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "e2f6825c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False  True  True  True  True  True  True  True  True]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([10,20,30,40,50,60,70,80,90,100])\n",
    "\n",
    "mask = arr > 20\n",
    "print(mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "ca6f8023",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 20,  30,  40,  50,  60,  70,  80,  90, 100])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[arr >= 20]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66c8b5f8",
   "metadata": {},
   "source": [
    "## 6. A note about copies vs 'views'\n",
    "\n",
    "See [Copies and views](https://numpy.org/doc/stable/user/quickstart.html#copies-and-views) in the user guide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "2d3852f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[30 40 50]\n"
     ]
    }
   ],
   "source": [
    "copy_arr = arr[2:5].copy()\n",
    "print(copy_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "74b98028",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 30 100  50]\n"
     ]
    }
   ],
   "source": [
    "copy_arr[1] = 100\n",
    "print(copy_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "20d952a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 10  20  30  40  50  60  70  80  90 100]\n"
     ]
    }
   ],
   "source": [
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "284c6a23",
   "metadata": {},
   "source": [
    "## 7. Saving NumPy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "6cbffe08",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('the_array.npy', arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "bec3b040",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 10  20  30  40  50  60  70  80  90 100]\n"
     ]
    }
   ],
   "source": [
    "new_array = np.load('the_array.npy')\n",
    "print(new_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08e868f9",
   "metadata": {},
   "source": [
    "## 8. Why numpy?\n",
    "\n",
    "NumPy is very fast when dealing with large, multidimensional arrays. In the following example, finding the mean pixel value of an image is almost 600 times faster using NumPy compared to loops.\n",
    "\n",
    "### 8.1. Load image as NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8ddc8f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Load and display the Fullstack Academy logo\n",
    "import PIL\n",
    "import urllib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Load the JPEG image\n",
    "image_url =     \"image_url = 'https://raw.githubusercontent.com/gperdrizet/FSA_devops/refs/heads/main/site/assets/fullstack-academy-logo-full-color-rgb.jpg'\\n\",\n",
    "logo = np.array(PIL.Image.open(urllib.request.urlopen(image_url)))\n",
    "\n",
    "# Display the image\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.imshow(logo)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d8a9bc54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image is type: <class 'numpy.ndarray'>\n",
      "Image array shape: (893, 3000, 3)\n"
     ]
    }
   ],
   "source": [
    "print(f\"Image is type: {type(logo)}\")\n",
    "print(f\"Image array shape: {logo.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95487cb0",
   "metadata": {},
   "source": [
    "### 8.2. Calculate the average pixel value\n",
    "\n",
    "#### With Python only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "5058c433",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method 1 - Standard Python (scaled):\n",
      "Average pixel value: 189.249193\n",
      "Time taken: 4.130554 seconds\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "# Method 1: Standard Python approach (with overflow prevention)\n",
    "start_time = time.time()\n",
    "\n",
    "# Scale pixel values to prevent overflow\n",
    "logo_scaled = logo.astype(float) / 255.0\n",
    "\n",
    "# Accumulator for pixel sum\n",
    "pixel_sum = 0.0\n",
    "\n",
    "# Nested loops through all dimensions\n",
    "for i in range(logo_scaled.shape[0]):\n",
    "    for j in range(logo_scaled.shape[1]):\n",
    "        for k in range(logo_scaled.shape[2]):\n",
    "            pixel_sum += logo_scaled[i, j, k]\n",
    "\n",
    "# Calculate average\n",
    "total_pixels = logo_scaled.shape[0] * logo_scaled.shape[1] * logo_scaled.shape[2]\n",
    "python_average = pixel_sum / total_pixels\n",
    "\n",
    "# Scale back to original range\n",
    "python_average_scaled = python_average * 255.0\n",
    "python_time = time.time() - start_time\n",
    "\n",
    "print(f\"Method 1 - Standard Python (scaled):\")\n",
    "print(f\"Average pixel value: {python_average_scaled:.6f}\")\n",
    "print(f\"Time taken: {python_time:.6f} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f6a885e",
   "metadata": {},
   "source": [
    "#### With NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "3cc51ca4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method 2 - NumPy:\n",
      "Average pixel value: 189.249193\n",
      "Time taken: 0.006361 seconds\n"
     ]
    }
   ],
   "source": [
    "# Method 2: NumPy approach\n",
    "start_time = time.time()\n",
    "\n",
    "numpy_average = np.mean(logo)\n",
    "\n",
    "numpy_time = time.time() - start_time\n",
    "\n",
    "print(f\"Method 2 - NumPy:\")\n",
    "print(f\"Average pixel value: {numpy_average:.6f}\")\n",
    "print(f\"Time taken: {numpy_time:.6f} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1944ea6c",
   "metadata": {},
   "source": [
    "### 8.3. Compare performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "5c85f89a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Comparison:\n",
      "NumPy is 649.38x faster than standard Python\n",
      "Speed improvement: 99.85%\n"
     ]
    }
   ],
   "source": [
    "# Compare results\n",
    "print(\"Comparison:\")\n",
    "print(f\"NumPy is {python_time / numpy_time:.2f}x faster than standard Python\")\n",
    "print(f\"Speed improvement: {((python_time - numpy_time) / python_time * 100):.2f}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "274bd9ad",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}