week_1_sharable.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "96ec3b9d-5ad3-4c6b-886e-89e8b71fe4bc",
   "metadata": {},
   "source": [
    "# Python Basics Week 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e606d414-0706-45f0-a1d8-7fa7c472dbde",
   "metadata": {},
   "source": [
    "Week one topics: \n",
    "- Jupyter Notebooks\n",
    "- Operators\n",
    "- Print()\n",
    "- Variable Assignment\n",
    "- Data Types\n",
    "- Input()\n",
    "- Commenting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "959097ec-77af-4fa0-8cac-8a594a476ef3",
   "metadata": {},
   "source": [
    "## Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "156326bf-c94a-4b6b-bfd7-873a00fc03dc",
   "metadata": {},
   "source": [
    "A Jupyter Notebook is a type of interactive development environment (IDE) that allows you to write and run Python code. Jupyter Notebooks also allow you to include formatted text (through Markdown) and even embed links, images, and other media in the notebook alongside your code.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a99a147f-13fc-4740-9538-9480cfd5fd38",
   "metadata": {},
   "source": [
    "These notebooks use the file extension .ipynb (as opposed to a python script, .py)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f54eae23-ef2e-489b-9481-6f46a017e763",
   "metadata": {},
   "source": [
    "By default, new cells are `code cells`. Use the dropdown menu on the toolbar at the top of the notebook to change a cell to a Markdown cell. Go to Help -> Markdown Reference to get a helpful cheat sheet for formatting text in Markdown."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c80d594e-344b-43c9-9d68-3b1715db9550",
   "metadata": {},
   "source": [
    "You can click and drag to the left of the cell to reorder cells in your notebook. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb9b33fe-7934-4848-b978-60e2dad591ed",
   "metadata": {},
   "source": [
    "Click the add cell buttons (next to the trash can) to add a cell above or below your current cell. (or, press ESC and then B to add a new cell below, A for a new cell above)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4e2be93-6ca4-4320-9caa-ec24a64fab12",
   "metadata": {},
   "source": [
    "Press shift + enter to run a cell (note to R users - command/ctrl + enter runs the cell but does not automatically create a new cell below). You can also use the play button on the toolbar at the top. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f1d70a3-a405-47f9-b9b3-52c8f2ccf5bc",
   "metadata": {},
   "source": [
    "## Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "783bc422-d7fd-4dd1-a146-fd88aafc470d",
   "metadata": {},
   "source": [
    "Operators are symbols, combinations of symbols, or keywords that designate some type of computation. There are a number of different operators used in Python. The most recognizable are the arithmetic operators: +, -, *, /, ** and %"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89f9e4af-00eb-4292-8fb6-a331ecc5a3ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "40 + 3 + 2  # addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "868d5a2a-9099-4228-b129-ed400362ff29",
   "metadata": {},
   "outputs": [],
   "source": [
    "25 - 21  # subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12e3835b-3156-43c2-9be6-d0dc51af7fbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "3*4  # multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc290d28-a861-4c51-af37-ba10ae0bc21b",
   "metadata": {},
   "outputs": [],
   "source": [
    "20/6  # division produces quotients as floating point numbers - we will talk about the different numeric types in a bit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "090b7b76-77f2-4108-9d4e-ac716758f4cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "20//6  # floor division returns a quotient rounded down to the nearest whole number (think of this as the whole number of times that the divisor fits into the dividend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "252f2272-598c-4fc8-94af-bec6d6da9539",
   "metadata": {},
   "outputs": [],
   "source": [
    "20%6  # the modulo operator returns the remainder after dividing two numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55e8212d-9472-433e-9d13-c347f2c77b86",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arithmetic operators also work with complex numbers:\n",
    "10/5j"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a88902a-be14-4e76-9646-df954d8ec67f",
   "metadata": {},
   "source": [
    "### Order of Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abd784b9-9a02-4bb0-8d3a-2d2e3b796e09",
   "metadata": {},
   "source": [
    "Python's order of operations is similar to what you might have learned in school, with a few tweaks. \n",
    "\n",
    "- Parentheses have the highest precedence, so when in doubt put it in parens! \n",
    "- Exponentiation has the next highest precedence. \n",
    "- Multiplication, division, floor division, and the modulo have equal precendence\n",
    "- Addition/subtraction have the lowest precendence of the aritmetic operators. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "490d0006-932f-460c-b7d5-c473ca5ab0d8",
   "metadata": {},
   "source": [
    "### Comparison Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "391abce0-9e8c-493f-8d23-c6cb2f074076",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The equality operator returns a boolean (True/False) value\n",
    "42 == 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b5102a4-fd71-4602-a1b3-2174f93f9551",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Not equal to:\n",
    "42 != 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f6620e5-9a93-4fd1-9f75-aba6032371c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Less than (and greater than)\n",
    "32 < 38"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d3aa349-1cc9-4b14-80cc-948dcc5b411e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Less than or equal to (and greater than or equal to)\n",
    "32 <= 88"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b5c558a-b763-447c-ac12-429a05e0a8e1",
   "metadata": {},
   "source": [
    "**Important** : If you work with decimal (floating point) numbers, be aware that computers will do funky things with decimals (especially infinitely repeating decimals) and you may not get the result you expect if you use the comparison operators to compare floating point numbers. See [this link](https://realpython.com/python-numbers/#make-python-lie-to-you) for further reading."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab6a7ec6-ff4f-48ab-a4df-61a324f84925",
   "metadata": {},
   "source": [
    "## The Print Function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93689d59-4973-4bf5-b783-4a22c7168bd4",
   "metadata": {},
   "source": [
    "Traditionally, the first thing you learn to do when learning a computer language is learn how to display the words \"Hello world!\". Fortunately, Python makes this quite straightforward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a15b8f16-6c9a-4210-9b1d-bfd2975b0dc6",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aedbf70-98ab-4fe9-87b7-6d1b4accbd7a",
   "metadata": {},
   "source": [
    "The `print()` function will display whatever is shown inside the parentheses to the right of the word `print`. We put *Hello world* in quotation marks (double or single) to tell Python that we are displaying text. The quotation marks around our text are not displayed. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88f4f4e5-fd56-4b7f-b8ec-a84c55862689",
   "metadata": {},
   "source": [
    "Calculations can be performed inside of `print()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00f0dd99-6292-4164-8e0f-192e2537fe54",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(4+3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f170152-f06e-4b55-9c50-c4f95676f6f8",
   "metadata": {},
   "source": [
    "We can print multiple things by separating them with commas. The result will print on one line. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71bbcec1-d82f-4b94-b8d8-80bbec57ef5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"20 divided by 6 is\", 20//6, \"with remainder\", 20%6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa6e3adc-fa95-47df-97ff-30be2131b4a5",
   "metadata": {},
   "source": [
    "## Variable Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e41e18d-9267-41e2-9700-0815748bafd9",
   "metadata": {},
   "source": [
    "Variables are (explanation of what a variable is)\n",
    "\n",
    "Variables in Python scripts have to follow certain rules:\n",
    "1. The variable cannot start with a number\n",
    "2. Variables are case-sensitive\n",
    "3. Variable names cannot contain special characters like !, @, #, * - only a-z, A-Z, 0-9, and the underscore ( _ )\n",
    "\n",
    "In addition to these rules, there are a few conventions that are typically followed:\n",
    "1. Variables are written in snake_case, though you may also see camelCasing\n",
    "2. Contants (as opposed to variables) are written in all caps\n",
    "3. Variables should be given short, descriptive names that are related to what they stand for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14431195-8029-4a6a-a2ab-d201458dee9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These are examples of valid variable names:\n",
    "pet = \"dog\"\n",
    "Pet = \"cat\"\n",
    "peT = \"snake\"\n",
    "_pet = \"fish\"\n",
    "pet1 = \"bird\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f31cbeee-1d49-470d-9752-8e7d721b43a2",
   "metadata": {},
   "source": [
    "Just to drive home that capitalization matters in variable names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b9ac386-ace4-41a8-83a2-209f871bb029",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(pet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f81ff762-2e99-4d05-964a-eecb1ab2bbcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Pet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "945e7247-8d4b-4878-84b5-cec1015e5919",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These are not valid variable names:\n",
    "&pet = \"dog\"\n",
    "1pet = \"bird\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42c201bd-2446-40ad-85d7-8109a509242d",
   "metadata": {},
   "source": [
    "### Assigning and Reassigning Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c0d3a57-200e-4a94-95d7-df91ed376a22",
   "metadata": {},
   "source": [
    "I think of a variable like a box that can hold a value. However, the box can only hold one value at a time. Reassigning the value of a variable removes the old value and will replace it in all instances where the variable is used. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94c5e912-39af-4d3f-bc35-15b8ce511230",
   "metadata": {},
   "source": [
    "Variables are assigned using the assignment operator: ="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a9cc11a-3971-4811-89df-b8d00a2a93f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_name = \"Shelby\"\n",
    "age = 30\n",
    "height = 63.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "631012cd-db89-4486-930b-a8ec6e719291",
   "metadata": {},
   "source": [
    "Variables must be assigned before they can be used (i.e. you need to run the cell before the variable can be used in other places). If a variable doesn’t exist yet, or if the name has been mispelled, Python reports an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e70151e0-9530-40b9-a14e-047871e8e3a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(last_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32f61369-315e-4cea-a988-4c6c92228248",
   "metadata": {},
   "source": [
    "Variables persist between cells in a notebook. The value of the variable comes from the cell which has been run the most recently, not necessarily from the order of the cells in the notebook. \n",
    "\n",
    "It can be helpful to use Kernel -> Restart & Run All to clear the interpreter and run everything from a clean slate going from top to bottom. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "413cb83d-6032-47b8-82f2-c6ffd20dc990",
   "metadata": {},
   "source": [
    "To reassign the value of a variable, you can use the same variable name and the assignment operator to assign a new value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8ebde4e-c081-40b4-91de-893be86078f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(first_name)  # first_name has an existing value of \"Shelby\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d30f817-561b-4297-98bf-62ea310182d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_name = \"Alex\"  # here we reassign the value of first_name to \"Alex\"\n",
    "print(first_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b10e54d-ad33-4e28-88e8-dd3825fbf09c",
   "metadata": {},
   "source": [
    "### Variables can be used in calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4a4754a-dd0b-4366-b404-1ec8cc612040",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Age in three years:\", age + 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40efa8da-8268-400a-8aea-a9997fb7dc22",
   "metadata": {},
   "outputs": [],
   "source": [
    "height * 2.54  # height in cm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3383e7eb-c9e0-49e1-a98b-52c93a569388",
   "metadata": {},
   "source": [
    "## Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86dd2f3b-7770-42ce-8a0e-cdd401db4c35",
   "metadata": {},
   "source": [
    "So far, you have seen three different types of data: strings, integers, and floating point (or decimal) numbers. \n",
    "\n",
    "- Strings are sequences of characters (in many cases, a \"string\" of letters, but numerals can also be strings)\n",
    "- Integers and floating point numbers (or \"floats\") are both numerical data types. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36513f00-33d9-423b-983a-1fe6cc090080",
   "metadata": {},
   "source": [
    "You can determine the data type of an expression or variable using the `type()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef2d2e0b-9f01-4b74-8d90-1a1640b19a64",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(52)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab46caeb-1407-4c1c-b961-0bccee232641",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(4.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0ddfa0c-c059-4926-af79-22646244907d",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(\"Shelby\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ae5413c-2a23-4aa5-a75e-51d7f34bfb71",
   "metadata": {},
   "source": [
    "Arithmetic operations can be performed with both integers and floats since they are both numeric:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99821bca-78a7-4a38-aec9-816e116167e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_number = 52 + 4.4\n",
    "print(new_number, type(new_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96a99956-4f42-4677-9b63-a9b6d1af4693",
   "metadata": {},
   "source": [
    "However, you cannot perform arithmetic operations with both numeric and non-numeric data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5f3cf86-3f79-4667-bd19-657985012bee",
   "metadata": {},
   "outputs": [],
   "source": [
    "4.4 + \"Shelby\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1615e619-5f75-4906-aa08-ec6570b8ba06",
   "metadata": {},
   "source": [
    "We will learn more about operations with strings next week."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5bccbaf-c6fe-4f2c-8847-9a1ca8b5642c",
   "metadata": {},
   "source": [
    "### Changing data types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "924bb1a3-9da7-4a92-abaa-488cc21c19e3",
   "metadata": {},
   "source": [
    "You can use the `int()`, `float()`, and `str()` functions to change an object's data type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "306686a4-2a2f-4745-8bc7-37e04e08646b",
   "metadata": {},
   "outputs": [],
   "source": [
    "float(52)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a253752d-131b-4f73-8f30-aec7bcd35cdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "int(4.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22c0d917-531e-428a-adfb-cf2055ee6af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "int(\"1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7723d166-007b-4217-9bf9-d801f1b1a605",
   "metadata": {},
   "outputs": [],
   "source": [
    "str(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9e0067c-9b90-44ca-bfdc-3908fde8fc7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can't, however, change alpha characters into numerics:\n",
    "int(\"one\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaca3e54-fd19-4453-bbcc-60869cbd6eea",
   "metadata": {},
   "source": [
    "## The Input Function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e89e2122-2add-4999-a9d6-49d2ba4974cd",
   "metadata": {},
   "source": [
    "You can assign a variable value by prompting input from a user using the `input()` function. This can be helpful for values that might change each time you run the script. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13a7deb1-8afc-487e-b380-30a13b0d2881",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input(\"What is your name?\")\n",
    "print(\"Good morning,\", name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1697c96-31a1-4eb6-aa03-98dc364866fb",
   "metadata": {},
   "source": [
    "One thing that is important to note is that inputted data is always interpreted as string data. You may need to convert the data to make it useful to you. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc4971b5-fa52-497e-a297-95ee1412ea74",
   "metadata": {},
   "outputs": [],
   "source": [
    "CURRENT_YEAR = 2024\n",
    "birth_year = input(\"What year were you born?\")\n",
    "print(\"You are\", CURRENT_YEAR - birth_year, \"years old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c7d7bd6-2d4f-442a-b76a-ca6de0a35993",
   "metadata": {},
   "source": [
    "Why didn't that work?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40dc35de-36b1-447c-831a-b9dccf9578a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(birth_year)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66c989a3-4c18-4467-a989-452cc6bbc929",
   "metadata": {},
   "source": [
    "What can we change to fix this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b34dd32-175f-4e0c-ba9f-10bec5c8efc4",
   "metadata": {},
   "outputs": [],
   "source": [
    "CURRENT_YEAR = 2024\n",
    "birth_year = int(input(\"What year were you born?\"))\n",
    "print(\"You are\", CURRENT_YEAR - birth_year, \"years old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "997e1e97-8e5d-49cf-acff-116c0f74dcaf",
   "metadata": {},
   "source": [
    "## Commenting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d646407c-89cb-4f2b-a79f-f3fe4e3ea1b6",
   "metadata": {},
   "source": [
    "You can add comments to code as helpful explanations and reminders by using the # symbol. \n",
    "\n",
    "Comments can appear on their own line by starting the line with a #."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa27bcce-2675-4290-9547-c8c2f3dc0b85",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mass in g\n",
    "mass = 3.85"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18f56913-24ce-4ec4-b2d5-702e9a534139",
   "metadata": {},
   "source": [
    "Comments can also be made \"inline\" as part of a line that also contains executable code. Anything that appears on the same line after a # counts as a comment, meaning it is not read and executed as part of the code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2036b122-bc4b-4039-b876-cf002d854a3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "mass = 3.85  # mass in g"
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}