19. NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*********************************************************************************************************\n",
    "# A Tour of Python 3  \n",
    "version 1.0.1  \n",
    "Authors: Phil Pfeiffer, Zack Bunch, and Feyisayo Oyeniyi  \n",
    "East Tennessee State University  \n",
    "Last updated June 2021  \n",
    "\n",
    "Chapter 19: author Ian Grisham; ed. Phil Pfeiffer  \n",
    "*********************************************************************************************************"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 19. NumPy  \n",
    " 19.1 [Background](#Numpy-Background)  \n",
    " 19.2 [Installation](#Numpy-Installation)  \n",
    " &ensp; 19.2.1 [Via Jupyter Notebook](#Numpy-Via-Jupyter-Notebook)  \n",
    " &ensp; 19.2.2 [Via the Command Line](#Numpy-Via-the-Command-Line)  \n",
    " 19.3 [Performance](#Numpy-Performance)  \n",
    " 19.4 [Using NumPy](#Numpy-Using-NumPy)  \n",
    " &ensp; 19.4.1 [Arrays](#Numpy-Arrays)  \n",
    " &ensp; 19.4.2 [Operators](#Numpy-Operators)  \n",
    " &ensp; 19.4.3 [Other Methods](#Numpy-Other-Methods)  \n",
    " 19.5 [Image Manipulation with NumPy](#Numpy-Image-Manipulation-with-NumPy) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  19.1  Background <a name='Numpy-Background'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy (Numerical Python), an open source library for scientific computing, ",
    "provides array-related data structures and associated functions. ",
    "NumPy began as underfunded project written primarily by unsanctioned graduate students, many of whom lacked formal computer science training. ",
    "Over time, NumPy has evolved into one of Python’s most commonly used libraries. ",
    "It’s used by scientific professionals worldwide; serves as the base for other scientific Python libraries; ",
    "and has supported groundbreaking scientific discoveries, ",
    "including the confirmation of Einstein's theory of gravitational waves and the first-ever imaging of a black hole (M-87)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  19.2  Installation <a name='Numpy-Installation'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  19.2.1 Via Jupyter Notebook <a name='Numpy-Via-Jupyter-Notebook'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy is not included in Python's basic libraries; it must be installed and then imported as a package. ",
    "To do so, first confirm you are running the latest version of Python by visiting ",
    "[Python's](https://www.python.org/downloads/) webpage ",
    "and checking your version against the most recent release."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## You can quickly check your version of Python using this code snippet ##\n",
    "# ! notation -  allows for shell commands to be executed.\n",
    "\n",
    "!python --version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To upgrade your pip installer via Jupyter notebook\n",
    "\n",
    "# Sys package provides access to some of the interpreter's metadata.\n",
    "import sys\n",
    "\n",
    "!pip install --upgrade pip\n",
    "\n",
    "# To ensure that NumPy is accessible by the current Python kernel, call sys.executable to access\n",
    "# \"the absolute path of the executable binary for the Python interpreter\".\n",
    "# You can read about its other methods at https://docs.python.org/3/library/sys.html\n",
    "!{sys.executable} -m pip install numpy\n",
    "\n",
    "# Confirm install.\n",
    "!pip show numpy\n",
    "\n",
    "# Visit the following section 'Via the Command Line' if Jupyter gives you any issues with the install"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  19.2.2  Via the Command Line <a name='Numpy-Via-the-Command-Line'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the library fails to download via the previous commands, \n",
    "- Download the necessary software via the command line. \n",
    "- Open a Windows command window (Windows Key + R --> type 'cmd').\n",
    "- Run the following the commands:\n",
    "  - `pip install --upgrade pip` &ensp; &ensp;  # Ensure you have the most recent version of pip\n",
    "  - `pip install numpy` &ensp; &ensp; &ensp; &ensp;  &ensp; &ensp; &ensp; &ensp; # Install NumPy\n",
    "  - `pip show numpy` &ensp; &ensp; &ensp; &ensp; &ensp; &ensp;  &ensp; &ensp; &ensp; &ensp; # Confirm your version\n",
    "\n",
    "To upgrade NumPy in the future, use pip: i.e., `pip install --upgrade numpy`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  19.3 Performance <a name='Numpy-Performance'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For collections of 5 million or more items, most NumPy operations are 100-150 times faster than their native Python counterparts. ",
    "NumPy's arrays are densely packed in memory, allowing for quick storage and retrieval. ",
    "NumPy also eliminates redundant type checks for *homogenous* arrays — arrays where all items are of the same type — ",
    "and processes common operations in parallel. These optimizations make NumPy attractive for managing large collections of items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [ ],
   "source": [
    "# Create a Python list with 50,000,000 elements and add 5 to each element.\n",
    "\n",
    "import time as t\n",
    "\n",
    "pythonsList = [i for i in range(50000000)]\n",
    "\n",
    "start = t.time()    # How long did the cell take to run? Start here.\n",
    "pythonsList = [i+5 for i in pythonsList]\n",
    "finish = t.time()   # How long did the cell take to run?\n",
    "\n",
    "print(f\"Add 5 to each element: {round(finish - start ,7)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [ ],
   "source": [
    "# Create an array using NumPy with 50,000,000 elements and add 5 to each element.\n",
    "\n",
    "import numpy as np\n",
    "import time as t\n",
    "\n",
    "npArray = np.array([i for i in range(50000000)])\n",
    "\n",
    "start = t.time()    # How long did the cell take to run? Start here.\n",
    "npArray += 5 #NumPy condensed add/equal operator. See operations section. \n",
    "finish = t.time()   # How long did the cell take to run?\n",
    "\n",
    "print(f\"Add 5 to each: {round(finish - start,7)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  19.4  Using NumPy <a name='Numpy-Using-NumPy'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  19.4.1  Arrays <a name='Numpy-Arrays'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy’s methods for creating and modifying arrays are documented in the ",
    "[NumPy manual](https://numpy.org/devdocs/reference/routines.array-manipulation.html). ",
    "Four common methods for creating arrays are shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Different methods of initializing arrays\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# Direct Method\n",
    "directMatrix = np.array([[1,2],[3,4]])\n",
    "\n",
    "# Arrays can be reshaped in NumPy to desired dimension by calling .reshape(dimensionSizes)\n",
    "reshaped = directMatrix.reshape(1, 4)\n",
    "\n",
    "# Zeros Method - (param -> total count)\n",
    "zerosMatrix = np.zeros(4).reshape(2,2)\n",
    "\n",
    "# Ones Method - (param -> total count)\n",
    "onesMatrix = np.ones(4).reshape(2,2)\n",
    "\n",
    "# Arange Method - (param -> loop header)\n",
    "\n",
    "# - From 0 to 6\n",
    "arangeTotalCountMatrix = np.arange(6).reshape(2,3)\n",
    "\n",
    "# - From 0 to 5 step by .25\n",
    "arangeFullLoopHeaderMatrix = np.arange(0, 5, .25).reshape(4,5) \n",
    "\n",
    "# - From 0 to 100 step by .33\n",
    "# - If passed -1, reshape automatically generates the other parameter based on what was provided. \n",
    "npColumnAutoCalcMatrix = np.arange(1, 10, .33).reshape(2, -1)\n",
    "npRowAutoCalcMatrix = np.arange(1, 10, .33).reshape(-1, 4)\n",
    "\n",
    "print(f\"Direct Method = \\n{directMatrix}\\n\",\n",
    "     f\"Reshaped =\\n{reshaped}\\n\",\n",
    "     f\"Zeros Matrix =\\n{zerosMatrix}\\n\",\n",
    "     f\"Ones Matrix =\\n{onesMatrix}\\n\",\n",
    "     f\"Arange using total count =\\n{arangeTotalCountMatrix}\\n\",\n",
    "     f\"Arange using full loop header (0, 5, .25) =\\n{arangeFullLoopHeaderMatrix}\\n\",\n",
    "     f\"Col auto calc (2, -1) =\\n{npColumnAutoCalcMatrix}\\n\",\n",
    "     f\"Row auto calc (-1, 4) =\\n{npRowAutoCalcMatrix}\\n\", sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following examples show NumPy-supported operations on four types of array-based data structures:\n",
    "\n",
    "- `Scalars` - 0-dimensional arrays that mimic numeric data types like short, int, etc.\n",
    "- `Vectors` - 1-dimensional arrays that mimic lists of numbers\n",
    "- `Matrices` - 2-dimensional arrays that mimic a list of lists \n",
    "- `Tensors`  - n-dimensional arrays that mimic vectors and matrices in dimensions higher than 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Create and initialize a scalar.\n",
    "scalar = np.array(5)\n",
    "\n",
    "# Use shape to confirm that scalar is 0-dimensional. Size displays the total number of items.\n",
    "shape = scalar.shape\n",
    "size = scalar.size\n",
    "\n",
    "\n",
    "# Because scalars mimic numeric data types, you can use them like one too.\n",
    "addResult = 5 + scalar\n",
    "subResult = 6 - scalar\n",
    "multiplyResult = 5*scalar\n",
    "divideResult = 5/scalar\n",
    "\n",
    "print(f\"Scalar Shape: {shape}\", \n",
    "      f\"Scalar Size: {size}\",\n",
    "      f\"Scalar operations: {addResult}, {subResult}, {multiplyResult}, {divideResult}\", sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Create and initialize a vector.\n",
    "vector = np.array([1, 2, 3])\n",
    "\n",
    "# Confirm that vector is 1-dimensional, with 3 items.\n",
    "shape = vector.shape\n",
    "size = vector.size\n",
    "\n",
    "# Vectors mimic lists\n",
    "item1 = vector[0]\n",
    "item2 = vector[1]\n",
    "item3 = vector[2]\n",
    "\n",
    "# Slicing allowed\n",
    "vectorSlice = vector[::-1]\n",
    "\n",
    "print(f\"Vector Shape: {shape}\", \n",
    "      f\"Vector Size: {size}\",\n",
    "      f\"Vector Items accessed via [index]: {item1}, {item2}, {item3}\", \n",
    "      f\"Vector index slice '[::-1]': {vectorSlice}\", sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Create and initialize several examples of matrices\n",
    "matrixArray = np.array([[1,2,3],[4,5,6]])\n",
    "matrixArange = np.arange(6).reshape(2,3)\n",
    "matrixZeros = np.zeros([2,3])\n",
    "matrixOnes = np.ones([2,3])\n",
    "\n",
    "print(f\"Array method:\\n{matrixArray}\",\n",
    "     f\"Arange method:\\n{matrixArange}\",\n",
    "     f\"Zeros method:\\n{matrixZeros}\",\n",
    "     f\"Ones method:\\n{matrixOnes}\",\n",
    "     sep='\\n\\n', end='\\n\\n')\n",
    "\n",
    "# Confirm that these matrices are 2-dimensional.\n",
    "shape = matrixArray.shape\n",
    "size = matrixArray.size\n",
    "\n",
    "# Matrices mimic a list of lists\n",
    "item1 = matrixArray[0][0]\n",
    "item2 = matrixArray[1][1]\n",
    "item3 = matrixArray[1][2]\n",
    "\n",
    "# Slicing still allowed. Slightly more complicated. \n",
    "matrixSlice = matrixArray[0:1, 1:2]\n",
    "\n",
    "print(f\"Matrix (arange method) Shape: {shape}\",\n",
    "      f\"Matrix (arange method) Size: {size}\",\n",
    "      f\"Matrix (arange method) Items accessed via [index][index]: {item1}, {item2}, {item3}\", \n",
    "      f\"Matrix (arange method) index slice '[0:1, 1:2]': {matrixSlice}\", sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Create and initialize a tensor.\n",
    "tensor = np.array([[[2, 4, 6],[2, 4, 6]],[[2, 4, 6],[2, 4, 6]]])\n",
    "\n",
    "# Confirm that tensor is 3-dimensional and that it holds 12 items\n",
    "shape = tensor.shape\n",
    "size = tensor.size\n",
    "\n",
    "# Can still index-- even more parameters.\n",
    "item1 = tensor[0][0][0]\n",
    "item2 = tensor[1][1][1]\n",
    "item3 = tensor[1][0][2]\n",
    "\n",
    "# Slicing still allowed here as well. As expected, more parameters are needed.\n",
    "tensorSlice = tensor[-1:, -1:, -1:]\n",
    "\n",
    "print(f\"Tensor Shape: {shape}\", \n",
    "      f\"Tensor Size: {size}\",\n",
    "      f\"Tensor Items accessed via index: {item1}, {item2}, {item3}\", \n",
    "      f\"Tensor index slice '[-1:, -1:, -1:]': {tensorSlice}\",  sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  19.4.2  Operators <a name='Numpy-Operators'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy supports Python-style arithmetic and logical operations on NumPy data objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "matrixA = np.array([[1,2],[4,5]])\n",
    "matrixB = np.array([[4,5],[1,2]])\n",
    "\n",
    "# Numerical Operator Demonstration\n",
    "# These operators all work on an element-by-element basis\n",
    "add = matrixA + matrixB\n",
    "subtract = matrixA - matrixB\n",
    "multiply = matrixA * matrixB\n",
    "divide = matrixA / matrixB\n",
    "\n",
    "print(f\"Matrix A before operations:\\n{matrixA}\\n\")\n",
    "\n",
    "matrixA += 2\n",
    "print(f\"MatrixA += 2:\\n{matrixA}\\n\")\n",
    "\n",
    "matrixA -= 2\n",
    "print(f\"MatrixA -= 2:\\n{matrixA}\\n\")\n",
    "\n",
    "matrixA *= 2\n",
    "print(f\"MatrixA *= 2:\\n{matrixA}\\n\")\n",
    "\n",
    "# Exponentiation also element-by-element basis\n",
    "exponent = matrixA**2\n",
    "\n",
    "# Matrix dot Product\n",
    "dotProduct = matrixA @ matrixB\n",
    "\n",
    "\n",
    "# Also supports logical operators \n",
    "greaterThan = matrixA>1\n",
    "lessThan = matrixB<3\n",
    "\n",
    "# Masking\n",
    "mask = matrixA>2\n",
    "matrixA[mask] = 0\n",
    "\n",
    "print(f\"MatrixA + MatrixB =\\n{add}\\n\",\n",
    "     f\"MatrixA - MatrixB =\\n{subtract}\\n\",\n",
    "     f\"MatrixA * MatrixB =\\n{multiply}\\n\",\n",
    "     f\"MatrixA / MatrixB =\\n{divide}\\n\",\n",
    "     f\"MatrixA ** 2 =\\n{exponent}\\n\",\n",
    "     f\"MatrixA @ MatrixB =\\n{dotProduct}\\n\",\n",
    "     f\"MatrixA > 1 =\\n{greaterThan}\\n\",\n",
    "     f\"MatrixB < 3 =\\n{lessThan}\\n\",\n",
    "     f\"Mask-- Where Matrix > 2 make it 0:\\n{matrixA}\\n\", sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  19.4.3  Other Methods <a name='Numpy-Other-Methods'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other NumPy methods to array manipulation are shown below. These include optimized versions of built-in Python methods on lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "matrixA = np.array([[1,2],[3,4]])\n",
    "matrixB = np.array([5,6,7,8])\n",
    "\n",
    "# Get the type of collection items using .dtype\n",
    "itemType = matrixA.dtype\n",
    "\n",
    "# Get the number of dimensions using .ndim\n",
    "dimensionCount = matrixA.ndim\n",
    "\n",
    "# Get the sum of all items in the collection using .sum\n",
    "sumA = np.sum(matrixA)\n",
    "\n",
    "# Get the smallest item in the collection using .min\n",
    "minA = np.min(matrixA)\n",
    "\n",
    "# Get the largest item in the collection using .max\n",
    "maxA = np.max(matrixA)\n",
    "\n",
    "# Get the square root of each item in the collection using np.sqrt(matrix)\n",
    "sqrt = np.sqrt(matrixA)\n",
    "\n",
    "# Find the mean of the collection using .mean\n",
    "mean = np.mean(matrixA)\n",
    "\n",
    "# Find the standard deviation of the collection using .std\n",
    "std = np.std(matrixA)\n",
    "\n",
    "# Flatten the array into 1-Dimension\n",
    "flat = np.ravel(matrixA)\n",
    "\n",
    "# Make a DEEP copy of the array\n",
    "copy = np.copy(matrixB)\n",
    "\n",
    "# Resize the array instead of reshaping it\n",
    "# Resize modifies the original array\n",
    "matrixB.resize(2, 2)\n",
    "\n",
    "# Stack arrays vertically using np.vstack(arrays)\n",
    "vstack = np.vstack((matrixA, matrixB))\n",
    "\n",
    "# Stack arrays horizontally using np.hstack(arrays)\n",
    "hstack = np.hstack((matrixA, matrixB))\n",
    "\n",
    "# Transpose the array. Affects data source\n",
    "transpose = np.transpose(hstack)\n",
    "\n",
    "print(f\"Matrix A =\\n{matrixA}\\n\",\n",
    "     f\"Item Type = {itemType}\\n\",\n",
    "     f\"Dimension Count = {dimensionCount}\\n\",\n",
    "     f\"Sum = {sumA}\\n\",\n",
    "     f\"Min = {minA}\\n\",\n",
    "     f\"Max = {maxA}\\n\",\n",
    "     f\"Mean = {mean}\\n\",\n",
    "     f\"Standard Deviation = {std}\\n\",\n",
    "     f\"Flattened =\\n{flat}\\n\",\n",
    "     f\"Square roots =\\n{sqrt}\\n\\n\",\n",
    "     f\"Matrix A =\\n{matrixA}\\n\",\n",
    "     f\"Matrix B =\\n{copy}\\n\",\n",
    "     f\"Copy of Matrix B =\\n{copy}\\n\",\n",
    "     f\"Size change using .resize(2,2) =\\n{matrixB}\\n\",\n",
    "     f\"Matrix B after resize =\\n{matrixB}\\n\",\n",
    "     f\"Vertical Stack =\\n{vstack}\\n\",\n",
    "     f\"Horizontal Stack =\\n{hstack}\\n\",\n",
    "     f\"Transpose of previous array =\\n{transpose}\\n\\n\", sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  19.5  Image Manipulation with NumPy  <a name='Numpy-Image-Manipulation-with-NumPy'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Run this code cell to download the packages used to process images. \n",
    "# If this code fails, use pip from a command line to install the packges directly. \n",
    "\n",
    "import sys \n",
    "\n",
    "!{sys.executable} -m pip install matplotlib\n",
    "!{sys.executable} -m pip install requests\n",
    "!{sys.executable} -m pip install pillow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading an image.\n",
    "\n",
    "import matplotlib.pyplot as plot\n",
    "import numpy as np\n",
    "import requests\n",
    "from PIL import Image\n",
    "\n",
    "# Get the image from the URL \n",
    "image = Image.open(requests.get('https://free-images.com/or/f988/colored_pencils_colour_pencils.jpg', stream=True).raw)\n",
    "\n",
    "# Cast to numpyArray\n",
    "numpyImage = np.array(image)\n",
    "\n",
    "# Show statistics\n",
    "print(f\"Type: {type(numpyImage)} with size: {numpyImage.shape}\")\n",
    "\n",
    "#Show the image\n",
    "plot.imshow(numpyImage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 19.5.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    "use some of the previously discussed methods to do the following:</span>\n",
    "- <span style='color:navy' >Split the image into 4 equally sized quadrants</span>\n",
    "- <span style='color:navy' >Fuse the quadrants back together. You can do this using only two functions</span>\n",
    "- <span style='color:navy' >Find all pixels where the red value of the pixel is 255</span>\n",
    "- <span style='color:navy' >Using a mask, change the color of all selected pixels to black (0 for all 3 RGB values)</span>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}