Lesson_3_Abstraction_Functions/Lesson_3_Abstraction_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/How-to-Learn-to-Code/python-class/blob/master/Lesson_3_Abstraction_Functions/functions.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 3 - Abstraction, Functions, and Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "T5WJjJnfpZWM"
   },
   "source": [
    "## Learning Objectives: \n",
    "\n",
    "Students will be able to design, use, and write functions with consistent variable scoping and design choices.\n",
    "\n",
    "* [Introduction to Abstraction](#abstraction)\n",
    "* [Writing Basic Functions](#basic_funcs)\n",
    "* [Calling Functions](#calling)\n",
    "* [Scope](#scope)\n",
    "* [Default Values](#defaults)\n",
    "* [Docstrings](#docstrings)\n",
    "* [Testing with `assert`](#testing)\n",
    "* [In-Class Exercises](#exercises)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction to Abstraction <a id='abstraction'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L7kujO9M3V0X"
   },
   "source": [
    "Abstraction is a core concept in programming; it's the idea of taking something complex and assigning it a simpler and more reusable form. You've already learned about a form of abstraction in Lessons 1 and 2: variables. When you assign a string, number, list, etc. to a variable you're separating the item (the data in the variable) from the accession (the variable name). \n",
    "\n",
    "This same idea can be applied to processes; these are called functions. Functions allow you to execute a series of commands using a single execution call and can be written to process multiple inputs by being called multiple times. \n",
    "\n",
    "Abstraction is a fundamentally difficult concept to grasp in programming, so don't feel bad if it takes a bit to wrap your head around."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Motivating Example\n",
    "\n",
    "Consider a common training task: building a calculator that can do the following with two numbers:\n",
    "    - Add\n",
    "    - Subtract\n",
    "    - Multiply \n",
    "    - Divide\n",
    "    - Calculate an exponent (raise the first number to the power of the second)\n",
    "\n",
    "We chose this because it is straightforward to understand, has a clear requirement for inputs/outputs, and is easily testable. You already learned how to do all of these mathematical operations, so the only novel concept will be related to building and running functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Pseudocode <a id='pseudocode'></a>\n",
    "\n",
    "When writing functions, it's important to think about 3 things:\n",
    "  - What does my function need to do? *or* What output should my function return?\n",
    "  - What input does it require?\n",
    "  - What steps need to happen to go from input to output?\n",
    "\n",
    "Writing out these requirements and steps in natural language is an organized and efficient way to understand your function before writing it, which makes the creation and testing easier. This is called *pseudocode* because it is not code but explains the logic behind a section of code and is organized in the same way as the code itself.\n",
    "\n",
    "Here's how I would write these notes for our calculator example:\n",
    "\n",
    "- **Input**: \n",
    "  - Mathematical operation\n",
    "  - Number 1\n",
    "  - Number 2\n",
    "- **Output**: \n",
    "  - Resulting value from operation\n",
    "- **Process (pseudocode)**:\n",
    "  - Check for inputted operation\n",
    "  - Calculate the operation using two inputted values\n",
    "  - Return resulting value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing Basic Functions <a id='basic_funcs'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With that, let's write our first, and simplest, form of a function: a function to add two numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(num_1, num_2):\n",
    "\n",
    "    result = num_1 + num_2\n",
    "    \n",
    "    return result\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "Note: you can also return without an intermediate variable\n",
    "\n",
    "def add(num_1, num_2):\n",
    "    return num_1 + num_2\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the function has three major components: \n",
    "- `def add(num_1, num_2):` which defines the name of the function and the inputs (arguments) in the function declaration.\n",
    "- The commands to be run whenever the function is called; we only have one in this case: `result = num_1 + num_2`.\n",
    "- `return result`, which tells the function that it's done everything it needs to and what value(s) to give to the global scope (more on that later). Whatever value(s) are returned can then be set as a variable when you call the function, as you'll see in the next block of code. \n",
    "  - Note: You can return multiple values by giving a comma separated list of them, e.g. `return foo, bar, baz`\n",
    "\n",
    "\n",
    "Also notice that if you try to run the code block above nothing happens. This is because all we've done so far is *define* the function, meaning we built the machinery, but we haven't actually used it yet. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calling Functions <a id='calling'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You've already run a function without realizing it through using the humble `print()`. If you've printed anything using that, you've run a function. `print()` takes in one or more arguments and outputs them to the terminal. Calling a function is usually as simple as calling print: you type the name of the function followed by parentheses containing the inputs. \n",
    "\n",
    "Let's give this a go with our adding function in a couple different flavors, all of which are functionally identical:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# All the following are equivalent\n",
    "\n",
    "# Positional args\n",
    "add_result = add(2, 8)\n",
    "\n",
    "# Keyword args\n",
    "add_result = add(num_1=2, num_2=8)\n",
    "\n",
    "# Positional args with variables\n",
    "num_1 = 2\n",
    "num_2 = 8\n",
    "add_result = add(num_1, num_2)\n",
    "\n",
    "# Keyword args with variables\n",
    "num_1 = 2\n",
    "num_2 = 8\n",
    "add_result = add(num_1=num_1, num_2=num_2)\n",
    "\n",
    "# A mix of positional and keyword args\n",
    "num_1 = 2\n",
    "num_2 = 8\n",
    "add_result = add(num_1, num_2=num_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, there are a few different ways you can specify inputs for functions:\n",
    "1. Positional arguments: assume the inputs are given in the same order as defined in the function definition (first argument for `add()` is always `num_1`, second is always `num_2`).\n",
    "2. Keyword arguments: explicitly state which argument you are assinging during the function call, non-ordered.\n",
    "\n",
    "Both methods are used in different contexts, generally it comes down to how complex a set of inputs are and your preferred style. Just remember that positional args are dependent on the order they're in within the function definition, so it's easier to make errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scope <a id='scope'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we're talking about input variables, it's important to consider *scope*. This is the concept that **whatever happens in a function stays in a function unless returned**, but the opposite is not true. \n",
    "\n",
    "Take the demonstrations for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global scope: accessible to all\n",
    "global_scope_tester = \"foo\"\n",
    "print(f\"Before function; outside of function scope: {global_scope_tester}\")\n",
    "\n",
    "def print_scope():\n",
    "    print(f\"Inside function; outside of function scope: {global_scope_tester}\")\n",
    "\n",
    "    # Local scope: accessible only within the function\n",
    "    local_scope_tester = \"bar\"\n",
    "    print(f\"Inside function; inside of function scope: {local_scope_tester}\")\n",
    "\n",
    "    return None\n",
    "\n",
    "print_scope()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that global variables are accessible to:\n",
    "- Code outside of functions\n",
    "- Code inside functions without passing them as input \n",
    "  - (Warning: this is bad practice and should not be used often; leads to difficult testing and untraceable code)\n",
    "\n",
    "You may notice that there is still a scenario missing: what if you try to print `local_scope_tester` outside of the function?\n",
    "\n",
    "Try to run the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Inside function; outside of function scope: {local_scope_tester}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you may have guessed, this code doesn't run. In fact, if you check carefully, you can see that the error type is a `NameError`, meaning that according to wherever the code is looking, there isn't a variable named `local_scope_tester`. That variable is considered local to the function, and unless you return the value, you can't access it outside of the function.\n",
    "\n",
    "Here's how to fix that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global scope: accessible to all\n",
    "global_scope_tester = \"foo\"\n",
    "print(f\"Defined before function; called outside of function scope: {global_scope_tester}\")\n",
    "\n",
    "def print_scope():\n",
    "    print(f\"Defined inside function; called outside of function scope: {global_scope_tester}\")\n",
    "\n",
    "    # Local scope: accessible only within the function\n",
    "    local_scope_tester = \"bar\"\n",
    "    print(f\"Defined inside function; called inside of function scope: {local_scope_tester}\")\n",
    "\n",
    "    return local_scope_tester\n",
    "\n",
    "local_scope_tester = print_scope()\n",
    "print(f\"Defined inside function; called outside of function scope: {local_scope_tester}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the motivation for returning values and writing organized input/output for your functions. Keeping scopes and i/o organized leads to readable and consistent code with minimal errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default Values <a id='defaults'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, you may have a function that will rarely need an input that is different from a known value. In our addition function, let's assume someone almost always wants to add 5 to a value. In situations like these, it's useful to add a default value in the function definition. This ensures a known outcome for the developer but also makes it easier for users to run code if they don't want to specify function inputs when the parameter value is (usually) obvious. \n",
    "\n",
    "Here's a re-definition of the addition machine with a default value of 5 for `num_2`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(num_1, num_2=5):\n",
    "\n",
    "    result = num_1 + num_2\n",
    "    \n",
    "    return result\n",
    "\n",
    "add_res = add(num_1=2)\n",
    "print(add_res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pretty simple, huh? To set a default value, all you need to do is set the input parameter equal to the default value in the definition. Whenever the function is called it now only requires `num_1`, since the function already knows what `num_2` is.\n",
    "\n",
    "Of course in this case since addition is commutative (doesn't matter which order the numbers are in), this is pretty useless. Let's write a subtraction function where the order of inputs matters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def subtract(num_1, num_2=5):\n",
    "\n",
    "    result = num_1 - num_2\n",
    "    \n",
    "    return result\n",
    "\n",
    "subtract_res = subtract(num_1=2)\n",
    "print(subtract_res)\n",
    "\n",
    "print(subtract(2, 3))\n",
    "print(subtract(9))\n",
    "print(subtract(num_1=43, num_2=12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hopefully you can see how default values are useful now, especially when you have a function being used many times. Default values are optional, use your best judgement to add them when they make sense for your function and the context it's being used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Docstrings <a id='docstrings'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can imagine that if you're writing a lot of functions that do a lot of different things just having the names be different might not be enough to easily figure out what you need quickly. Luckily there is a standardized solution to this: docstrings. These are little descriptor blocks below a function definition to clarify what a function does, what it's inputs/outputs are, and any other relevant information (such as stackoverflow citations!)\n",
    "\n",
    "There are multiple docstring format standards, but we'll use the Google style. VSCode even has automatic docstring generators to make the process even easier. Here's the template for a Google style docstring:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_with_types_in_docstring(param1, param2):\n",
    "    \"\"\"Example function with types documented in the docstring.\n",
    "\n",
    "    General notes here\n",
    "\n",
    "    Args:\n",
    "        param1 (type): The first parameter.\n",
    "        param2 (type): The second parameter.\n",
    "\n",
    "    Returns:\n",
    "        type: The return value. True for success, False otherwise.\n",
    "\n",
    "    .. Links:\n",
    "        https://www.python.org/dev/peps/pep-0484/\n",
    "\n",
    "    .. TODO\n",
    "        foo\n",
    "        bar\n",
    "\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that these types of text blocks can be used for a script as well, so you can have consistently organized code from top to bottom.\n",
    "\n",
    "Let's go ahead and define all the other functions needed for our calculator with some basic docstrings to exemplify the process:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(num_1, num_2):\n",
    "    \"\"\"Add two numbers together.\"\"\"\n",
    "    result = num_1 + num_2\n",
    "    \n",
    "    return result\n",
    "\n",
    "def subtract(num_1, num_2):\n",
    "    \"\"\"\n",
    "    Subtract num_2 from num_1.\n",
    "\n",
    "    Args:\n",
    "        num_1 (Union[int, float]): Number to subtract from.\n",
    "        num_2 (Union[int, float]): Number to subtract with.\n",
    "\n",
    "    Returns:\n",
    "        Union[int, float]: Result of subtraction process.\n",
    "    \"\"\"\n",
    "    result = num_1 - num_2\n",
    "    \n",
    "    return result\n",
    "\n",
    "def multiply(num_1, num_2):\n",
    "    \"\"\"Multiply two values together, order doesn't matter.\"\"\"\n",
    "    return num_1 * num_2\n",
    "    \n",
    "def divide(num_1, num_2):\n",
    "    \"\"\"Wait, which number is the numerator and which is the denominator?\"\"\"\n",
    "    result = num_1 / num_2\n",
    "    \n",
    "    return result\n",
    "\n",
    "def exponent(num_1, num_2):\n",
    "    \"\"\"Take num_1 to the power of num_2\"\"\"\n",
    "    result = num_1 ** num_2\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have all our components, we can build the calculator. Remember, here is our function design:\n",
    "- **Input**: \n",
    "  - Mathematical operation\n",
    "  - Number 1\n",
    "  - Number 2\n",
    "- **Output**: \n",
    "  - Resulting value from operation\n",
    "- **Process (pseudocode)**:\n",
    "  - Check for inputted operation\n",
    "  - Calculate the operation using two inputted values\n",
    "  - Return resulting value\n",
    "\n",
    "Knowing that, we'll follow this design pretty closely:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculator(operation, num_1, num_2):\n",
    "    \"\"\"\n",
    "    Calculates a value given a mathematical operation and two values.\n",
    "\n",
    "    Args:\n",
    "        operation (str): Choice of [\"add\", \"subtract\", \"multiply\", \"divide\", \"exponent\"]\n",
    "        num_1 (Union[int, float]): Value 1\n",
    "        num_2 (Union[int, float]): Value 2\n",
    "\n",
    "    Returns:\n",
    "        Union[int, float]: Value returned from the desired math operation.\n",
    "    \"\"\"\n",
    "    if operation == \"add\":\n",
    "        res = add(num_1, num_2)\n",
    "    elif operation == \"subtract\":\n",
    "        res = subtract(num_1, num_2)\n",
    "    elif operation == \"multiply\":\n",
    "        res = multiply(num_1, num_2)\n",
    "    elif operation == \"divide\":\n",
    "        res = divide(num_1, num_2)\n",
    "    elif operation == \"exponent\":\n",
    "        res = exponent(num_1, num_2)\n",
    "    else:\n",
    "        print(\"Bad input\")\n",
    "        res = None\n",
    "\n",
    "    return res\n",
    "\n",
    "calculator(\"sum\", 2, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see this function follows a pretty clear logic: depending on the desired operation, it runs the function defined above with the given values, and then returns the value gotten from that. This is meant to demonstrate how functions can be run inside of functions and the results used within the external function. This structure can be done repeatedly for a nested structure, or you can design a process to use a flat structure where you minimally nest function calls. The theory behind which is better is hotly debated, but a good rule of thumb is that as long as it follows a consistent logic and you document your functions well, nesting can be a great way to chain operations together, such as above. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing with `assert` <a id='testing'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we've completed our function, it's time to test it. Testing is often overlooked in the world of scientific computing, but it is arguably *more* important when dealing with high amounts of data and long workflows to ensure consistent results. \n",
    "\n",
    "In Python, testing is extremely straightforward with the `assert` command. At its most basic, `assert` allows you to compare any two values: if they are the same, it returns with a value of True and does nothing, but if not, it returns a value of False and raises an error. This allows us to test a given function by writing a \"unit test\" for the function, where we input a known value with a known outcome and test whether the function responds appropriately.\n",
    "\n",
    "Here is a basic example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Passes, nothing happens\n",
    "assert calculator(\"add\", 2, 2) == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fails, raises an error\n",
    "assert calculator(\"add\", 2, 2) == 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see when an assertion fails, it raises a specific type of error called an `AssertionError`. If you don't want the program to proceed if the test fails, you can just let it error out. Note that you can also add a message for the assertion error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fails, raises an error\n",
    "assert calculator(\"add\", 2, 2) == 5, \"Addition test failed!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to acknowledge and error happened but keep going, you can use something called a `try/except` block. Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    assert calculator(\"add\", 2, 2) == 5\n",
    "except AssertionError:\n",
    "    print(\"Test failed!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this is handy for small situations, it's preferable to write unit tests for all functions and store them in separate modules for your code. While automated unit testing is outside of the scope of this lecture, we highly recommend you read [this excellent tutorial on RealPython.](https://realpython.com/python-testing/) \n",
    "\n",
    "Consistent and robust unit testing will not only save your code from silently producing erroneous results, it will ensure your code is reproducible even if you make changes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### In-Class Exercises <a id='exercises'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following exercises will help you better understand functions, scope, and testing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hOggiwzmMm1Z"
   },
   "source": [
    "1. Write a function that given two positional args, returns them in the opposite order, i.e. second then first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def swapper(v1, v2):\n",
    "    return v2, v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Write a better docstring for the `divide()` function defined earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jj1BdK9TiThp"
   },
   "outputs": [],
   "source": [
    "def divide(num_1, num_2):\n",
    "    \"\"\"\n",
    "    Divides num_1 by num_2.\n",
    "\n",
    "    Args:\n",
    "        num_1 (Union[int, float]): Numerator\n",
    "        num_2 (Union[int, float]): Denominator\n",
    "\n",
    "    Returns:\n",
    "        Union[int, float]: Result of division.\n",
    "    \"\"\"\n",
    "    result = num_1 / num_2\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Write a function that subtracts a global variable from a local variable and returns the result. Print said result to verify it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_1 = 5\n",
    "\n",
    "def global_sub(val_2):\n",
    "    return val_2 - val_1\n",
    "\n",
    "global_sub(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Write a unit test for any of the calculator sub-functions above. Write a conditional print statement (i.e. using `try` and `except`) based on the output, as demonstrated above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for test in [2, 3]:\n",
    "    try:\n",
    "        print(f\"Testing value: {test}\")\n",
    "        assert subtract(4, 2) == test\n",
    "        print(\"Passed!\\n\")\n",
    "    except AssertionError:\n",
    "        print(f\"Didn't work with {test}!\\n\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "Lesson 2.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "interpreter": {
   "hash": "cdb21742b32bb92720e0f893b2791b7d15f4eec91bb98c4d2dc907dc4502837f"
  },
  "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}