3_Functions-and-Modules.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c973c69c-6b8d-4989-9ddd-6907d6c02793",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>table {align:left;display:block} </style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "table_css = 'table {align:left;display:block} '\n",
    "HTML('<style>{}</style>'.format(table_css))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b93e6f5d-d88b-43de-a6d0-18b2a54f0918",
   "metadata": {},
   "source": [
    "# **ASI WA Python Workshop**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3098bd0d-cb71-4c52-b292-d316c5003a0a",
   "metadata": {
    "tags": []
   },
   "source": [
    "## **Jupyter Notebook Tips**\n",
    "\n",
    "Outside of a cell:\n",
    "\n",
    "| key combo | action |\n",
    "| :--: | ---- |\n",
    "| shift+enter |  run a cell |\n",
    "| b |  insert cell below | \n",
    "| a |  insert cell above |\n",
    "| dd | delete selected cell |\n",
    "\n",
    "<br>\n",
    "Within a cell:\n",
    "\n",
    "| key combo | action |\n",
    "| :--: | ---- |\n",
    "| Command + / |  comment out line(s) |\n",
    "| Alt + Cursor | vertical selection |\n",
    "\n",
    "**Control = Command\n",
    "<br><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b220a4-df90-4c81-bb81-5b4186a2b41a",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "## **Functions**\n",
    "So far we have seen many built-in Python functions. In this section, we will focus on custom functions. What is a function? Before we start making functions, let us learn what a function is and why we need them?\n",
    "\n",
    "A function is a reusable block of code or programming statements designed to perform a certain task. To define or declare a function, Python provides the def keyword. The following is the syntax for defining a function. The function block of code is executed only if the function is called or invoked.\n",
    "\n",
    "\n",
    "```\n",
    "# syntax\n",
    "# Declaring a function\n",
    "def function_name():\n",
    "    codes\n",
    "    codes\n",
    "    \n",
    "# Calling a function\n",
    "function_name()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c463aac8-7f7f-40ac-8528-f64e70accd2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# declare your function\n",
    "def my_first_function():\n",
    "    print(\"Hello from a function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "dd4a856e-3c2d-4c3b-a9f9-388525900a43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from a function\n"
     ]
    }
   ],
   "source": [
    "# call your function\n",
    "my_first_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef1ffcc9-8ac0-4526-a308-efcce29ecdb3",
   "metadata": {},
   "source": [
    "### Passing arguments or parameters to a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b5c766c4-19d2-462d-b492-67183d0979d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Poopoo Bumbum\n"
     ]
    }
   ],
   "source": [
    "def name_function(first, last):\n",
    "    print(first + \" \" + last)\n",
    "\n",
    "name_function(\"Poopoo\", \"Bumbum\") # example name provide by Lenny"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "188f3995-02dd-4ec9-bf52-e48fe8d4e2fe",
   "metadata": {},
   "source": [
    "### Returning a value from a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "95497e10-4bb4-4d03-a694-e849cf226657",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add_two_numbers(a,b):\n",
    "    total = a + b\n",
    "    return total\n",
    "\n",
    "add_two_numbers(5,15)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bb95777-74eb-4604-a7fc-f599cdfcc838",
   "metadata": {},
   "source": [
    "You should use a function anytime you find yourself repeating the same code over and over. For example, if you need to calculate student grades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8dffdf3d-9b7e-4356-88df-9aa739369203",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "86.8\n",
      "83.0\n",
      "91.0\n"
     ]
    }
   ],
   "source": [
    "# calculate grades of student1\n",
    "student1_grades = [85, 90, 92, 88, 79]\n",
    "total1 = sum(student1_grades)\n",
    "count1 = len(student1_grades)\n",
    "average1 = total1 / count1\n",
    "print(average1)\n",
    "\n",
    "# calculate grades of student2\n",
    "student2_grades = [77, 83, 92, 78, 85]\n",
    "total2 = sum(student2_grades)\n",
    "count2 = len(student2_grades)\n",
    "average2 = total2 / count2\n",
    "print(average2)\n",
    "\n",
    "# calculate grades of student1\n",
    "student3_grades = [90, 92, 94, 88, 91]\n",
    "total3 = sum(student3_grades)\n",
    "count3 = len(student3_grades)\n",
    "average3 = total3 / count3\n",
    "print(average3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b83038a-7d19-4a13-9d50-cff38a750adb",
   "metadata": {},
   "source": [
    "A function significantly enhances code readability, simplifies modifications, and reduces the amount of code required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "01e350ba-7529-4369-94c0-b2530d72d97e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "86.8\n",
      "83.0\n",
      "91.0\n"
     ]
    }
   ],
   "source": [
    "def calculate_average_grade(grades):\n",
    "    total = sum(grades)\n",
    "    count = len(grades)\n",
    "    average = total / count\n",
    "    print( average)\n",
    "    return average # we can return a value(s)\n",
    "\n",
    "student1_grades = [85, 90, 92, 88, 79]\n",
    "average1 = calculate_average_grade( student1_grades)\n",
    "\n",
    "student2_grades = [77, 83, 92, 78, 85]\n",
    "average2 = calculate_average_grade( student2_grades)\n",
    "\n",
    "student3_grades = [90, 92, 94, 88, 91]\n",
    "average3 = calculate_average_grade( student3_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f6a13be-dbfd-49d2-96e0-b02df655f0b7",
   "metadata": {},
   "source": [
    "### Default parameters with a function\n",
    "Sometimes we pass default values to parameters, when we invoke the function. If we do not pass arguments when calling the function, their default values will be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "21592474-843f-45a2-9104-5f34e1aeffe8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chuck Bumbum\n",
      "Chuck Herring\n"
     ]
    }
   ],
   "source": [
    "def your_Lenny_name(first, last='Bumbum'):\n",
    "    print(first + \" \" + last)\n",
    "\n",
    "# if last is not passed default is used \n",
    "your_Lenny_name( 'Chuck')\n",
    "# if last is passed default is not used\n",
    "your_Lenny_name( 'Chuck', last='Herring')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cce8ac7-0943-4ccf-aa8f-2c3e2d17e96c",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "#### *Task 3.1: Temperature Conversion*\n",
    "Temperature in °C can be converted to °F using this formula: °F = (°C x 9/5) + 32. Write a function which takes °C and returns °F."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "80af1053-897d-46e1-b11a-63ead7f8c6fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "212.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 3.1\n",
    "\n",
    "def c_to_f(c):\n",
    "    f = (c * 9/5) + 32\n",
    "    return(f)\n",
    "\n",
    "c_to_f(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86d69c7c-e3a0-49fc-a6f9-4fd7d8451ac3",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "#### *Task 3.2: Print a List*\n",
    "Declare a function named print_list. It takes a list as a parameter and it prints out each element of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0c636ca7-8882-4d73-ae7c-731ce58467c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "2\n",
      "Cee\n"
     ]
    }
   ],
   "source": [
    "# Task 3.2\n",
    "\n",
    "def print_list(list1):\n",
    "    for ii in list1:\n",
    "        print(ii)\n",
    "    return\n",
    "\n",
    "print_list(['a',2,'Cee'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9d66bd8-f243-41a5-8983-c07b3a8ff5cd",
   "metadata": {},
   "source": [
    "<br><br>\n",
    "## **Introduction to Modules**\n",
    "A module is a file containing a set of codes or a set of functions which can be included to an application. A module could be a file containing a single variable, a function or a big code base.\n",
    "\n",
    "### Creating a Module \n",
    "To create a module we write our codes in a python script and we save it as a .py file. Create a file named mymodule.py inside your project folder. Here is an example.\n",
    "\n",
    "\n",
    "Within a file named mymodule.py you can place this function (I have already done this for you):\n",
    "\n",
    "---------------------------------------------\n",
    "```\n",
    "# mymodule.py file\n",
    "def generate_full_name(firstname, lastname):\n",
    "    return firstname + ' ' + lastname\n",
    "```\n",
    "----------------------------------------------\n",
    "\n",
    "### Importing a Module\n",
    "To import the file we use the *import* keyword and the name of the file only. We can then call a function with a dot (.) \n",
    "```\n",
    "module_name.function()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7e613c56-6b17-47a1-a373-9ec75e5e00e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chuck Herring\n"
     ]
    }
   ],
   "source": [
    "# main.py file\n",
    "import mymodule # importing the python file\n",
    "\n",
    "print( mymodule.generate_full_name('Chuck', 'Herring')) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9a140f4-587d-4efb-92dd-93afa548b917",
   "metadata": {},
   "source": [
    "### Import Functions from a Module\n",
    "We can also directly import a function from a module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4e7a5941-5411-40ad-8457-b12852d0edc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chuck Herring\n"
     ]
    }
   ],
   "source": [
    "from mymodule import generate_full_name # import function from module\n",
    "\n",
    "print( generate_full_name('Chuck', 'Herring')) # call function directly"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "224e31d1-ff6d-4c12-8d1b-b64c2a678257",
   "metadata": {},
   "source": [
    "## **Import Built-in Modules**\n",
    "Similar to other programming languages, Python allows us to import modules by using the keyword *import*. We can import specific files or functions. In this workshop, let's import the commonly used modules such as math, statistics, and os.\n",
    "\n",
    "### Math Module with importing functions\n",
    "Module containing many mathematical operations and constants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "2a458760-e5aa-4fec-a458-db110a521331",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "1.4142135623730951\n",
      "8.0\n",
      "9\n",
      "10\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(math.pi)           # 3.141592653589793, pi constant\n",
    "print(math.sqrt(2))      # 1.4142135623730951, square root\n",
    "print(math.pow(2, 3))    # 8.0, exponential function\n",
    "print(math.floor(9.81))  # 9, rounding to the lowest\n",
    "print(math.ceil(9.81))   # 10, rounding to the highest\n",
    "print(math.log10(100))   # 2, logarithm with 10 as base"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a747868d-833b-4530-9a48-afad1db39e1a",
   "metadata": {},
   "source": [
    "We can also import multiple functions at the sametime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f62746a9-9dc2-4260-931e-7c7ea2cf6e73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "1.4142135623730951\n",
      "8.0\n"
     ]
    }
   ],
   "source": [
    "from math import pi, sqrt, pow\n",
    "print(pi)                 # 3.141592653589793\n",
    "print(sqrt(2))            # 1.4142135623730951\n",
    "print(pow(2, 3))          # 8.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a69c674a-aa99-40fb-a279-8ff80eb8a560",
   "metadata": {},
   "source": [
    "If we want to import all the function in math module we can use * ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1bde1a48-e226-4144-987c-a8c9d7c9749f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "1.4142135623730951\n",
      "8.0\n",
      "9\n",
      "10\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "print(pi)                  # 3.141592653589793, pi constant\n",
    "print(sqrt(2))             # 1.4142135623730951, square root\n",
    "print(pow(2, 3))           # 8.0, exponential\n",
    "print(floor(9.81))         # 9, rounding to the lowest\n",
    "print(ceil(9.81))          # 10, rounding to the highest\n",
    "print(math.log10(100))     # 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5897baa-c91f-4ac7-8494-b6dbfdc5032d",
   "metadata": {},
   "source": [
    "### Statistics Module with a name change\n",
    "The statistics module provides functions for mathematical statistics of numeric data. The popular statistical functions which are defined in this module: mean, median, mode, stdev etc. We change the name of an module on import as the *as* keyword. Below we import the statistics module and shorten its name to stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6098318a-86d2-48c1-aced-305a9ae94cf0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21.09090909090909\n",
      "22\n",
      "20\n",
      "6.106628291529549\n"
     ]
    }
   ],
   "source": [
    "import statistics as stats # importing and renaming the statistics module\n",
    "ages = [20, 20, 4, 24, 25, 22, 26, 20, 23, 22, 26]\n",
    "print(stats.mean(ages))    \n",
    "print(stats.median(ages))  \n",
    "print(stats.mode(ages))    \n",
    "print(stats.stdev(ages))   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8912cd09-b701-4ded-a902-ab3dfa921202",
   "metadata": {},
   "source": [
    "### OS Module\n",
    "The Python os module provides a wide range of functions to automate various operating system tasks. It allows you to perform actions such as creating and removing directories (folders), changing the current working directory, retrieving directory contents, and identifying the current directory. By leveraging the os module, you can streamline and automate many operating system-related operations within your Python programs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "bd43ee19-bc75-4828-88ca-ed95dd05f613",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the module\n",
    "import os\n",
    "# Creating a directory\n",
    "os.mkdir('directory_name')\n",
    "# # Changing the current directory\n",
    "# os.chdir('path')\n",
    "# Getting current working directory\n",
    "os.getcwd()\n",
    "# Removing directory\n",
    "os.rmdir('directory_name')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c22ffc32-6dfa-4fc6-ba77-5ede08c6e213",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='1.1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fe7e3d2-6410-440b-a020-138b70f57aed",
   "metadata": {},
   "source": [
    "### `?` also works for modules and their functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0542b51d-0cd5-4ff0-86a6-59ce751548c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mType:\u001b[0m        module\n",
       "\u001b[0;31mString form:\u001b[0m <module 'os' from '/home/chuck/anaconda3/lib/python3.9/os.py'>\n",
       "\u001b[0;31mFile:\u001b[0m        ~/anaconda3/lib/python3.9/os.py\n",
       "\u001b[0;31mDocstring:\u001b[0m  \n",
       "OS routines for NT or Posix depending on what system we're on.\n",
       "\n",
       "This exports:\n",
       "  - all functions from posix or nt, e.g. unlink, stat, etc.\n",
       "  - os.path is either posixpath or ntpath\n",
       "  - os.name is either 'posix' or 'nt'\n",
       "  - os.curdir is a string representing the current directory (always '.')\n",
       "  - os.pardir is a string representing the parent directory (always '..')\n",
       "  - os.sep is the (or a most common) pathname separator ('/' or '\\\\')\n",
       "  - os.extsep is the extension separator (always '.')\n",
       "  - os.altsep is the alternate pathname separator (None or '/')\n",
       "  - os.pathsep is the component separator used in $PATH etc\n",
       "  - os.linesep is the line separator in text files ('\\r' or '\\n' or '\\r\\n')\n",
       "  - os.defpath is the default search path for executables\n",
       "  - os.devnull is the file path of the null device ('/dev/null', etc.)\n",
       "\n",
       "Programs that import and use 'os' stand a better chance of being\n",
       "portable between different platforms.  Of course, they must then\n",
       "only use functions that are defined by all platforms (e.g., unlink\n",
       "and opendir), and leave all pathname manipulation to os.path\n",
       "(e.g., split and join).\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "309a29f9-d478-4cf2-a5fb-a99f1135bc01",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "Change the current working directory to the specified path.\n",
       "\n",
       "path may always be specified as a string.\n",
       "On some platforms, path may also be specified as an open file descriptor.\n",
       "  If this functionality is unavailable, using it raises an exception.\n",
       "\u001b[0;31mType:\u001b[0m      builtin_function_or_method\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?os.chdir"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d758cfc-2ad6-41c1-9a21-7495891adb20",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='1.1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b052cd8e-63b4-47cb-a88f-3dd82fbc93f5",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "#### *Task 3.3: Using Built-in Modules*\n",
    "\n",
    "Import the math module using the import keyword and rename it maths.\n",
    "\n",
    "Import the random module using the from keyword and import the randint function from it.\n",
    "\n",
    "Import all functions and variables from the os module using the from keyword and the * wildcard.\n",
    "\n",
    "Test each imported module/function:\n",
    "\n",
    "1. Use the math.sqrt() function to calculate the square root of a given number.\n",
    "\n",
    "2. Generate a random integer between 1 and 10 using the randint() function.\n",
    "\n",
    "3. Print the current working directory using the os.getcwd() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "50e1da3c-574b-4805-afc2-27a106e1d009",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 3.3.1\n",
    "import math as maths\n",
    "\n",
    "maths.sqrt(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "a23773ae-790f-4a14-8582-17387a251fb2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 3.3.2\n",
    "from random import randint\n",
    "randint(1,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a06f8ba6-5dca-4090-a2d1-070d9af4c416",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/chuck/workspace/python_workshop'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Task 3.3.3\n",
    "from os import *\n",
    "getcwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c7c2751-c349-47f5-b42a-1b7141830a7f",
   "metadata": {},
   "source": [
    "<br><br>\n",
    "References:\n",
    "- https://github.com/Asabeneh/30-Days-Of-Python/blob/master/12_Day_Modules/12_modules.md"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}