Let's Learn Python/01. Python - Numeric Data Types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dba8e169",
   "metadata": {},
   "source": [
    "# 1. Numbers in Python\n",
    "\n",
    "In this section, We'll dive into the world of numbers and learn how to use them effectively in Python.\n",
    "\n",
    "We'll learn about the following topics:\n",
    "\n",
    "   - [1.1. Types of Numbers in Python](#Types_of_Numbers_in_Python)\n",
    "   - [1.2. Python Built-in Arithmetic Operators](#Python_Builtin_Arithmetic_Operators)\n",
    "   - [1.3. Python Built-in Arithmetic Functions](#Python_Builtin_Arithmetic_Functions)\n",
    "   - [1.4. Variable Assignment](#Variable_Assignment)\n",
    "   - [1.5. Variable Reassignment](#Variable_Reassignment)\n",
    "   - [1.6. Determining Variable Type](#Determining_Variable_Type)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86006a17",
   "metadata": {},
   "source": [
    "<p align=\"center\">\n",
    "  <img width=\"550\" height=\"300\" src=\"https://realpython.com/cdn-cgi/image/width=960,format=auto/https://files.realpython.com/media/Python-Basics-Chapter-Numbers-in-Python_Watermarked.70cee8925cbf.jpg\">\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac5e5d0e",
   "metadata": {},
   "source": [
    "<a name='Types_of_Numbers_in_Python'></a>\n",
    "\n",
    "## 1.1. Types of Numbers in Python:\n",
    "\n",
    "\n",
    "Python offers different kinds of numbers. We'll mainly work with integers and floating-point numbers.\n",
    "\n",
    "**Integers** are whole numbers, positive or negative. For example: 5 or -5.\n",
    "\n",
    "**Floating-point numbers** are numbers with a decimal point or those represented in scientific notation. They can be used to represent a wide range of values, including very large or very small numbers. For example: 4E2 (4 times 10 to the power of 2) or 4.56.\n",
    "\n",
    "Here is a table of the two main types we will spend most of our time working with some examples:\n",
    "\n",
    "<table>\n",
    "<tr>\n",
    "    <th>Examples</th> \n",
    "    <th>Number Type</th>\n",
    "</tr>\n",
    "\n",
    "<tr>\n",
    "    <td>1,5,-7,1400</td>\n",
    "    <td>Integers</td> \n",
    "</tr>\n",
    "\n",
    "<tr>\n",
    "    <td>1.3,-0.8,2e2,4E9</td> \n",
    "    <td>Floating-point numbers</td> \n",
    "</tr>\n",
    " </table>\n",
    " \n",
    " \n",
    " \n",
    "Be aware that Python recognizes 1 an integer, but 1.0 as a float."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "476ec4b0",
   "metadata": {},
   "source": [
    "To make large numbers easier to read, we often group digits into threes with commas. Python doesn't allow commas within numbers, but you can use underscores `_` instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c19c71d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000000"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Integer\n",
    "1_000_000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8fbc951a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000000.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Float\n",
    "1_000_000.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74de4f4a",
   "metadata": {},
   "source": [
    "<a name='Python_Builtin_Arithmetic_Operators'></a>\n",
    "\n",
    "## 1.2. Python Built-in Arithmetic Operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1947ecc6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Addition\n",
    "6+3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "13b3a27f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Subtraction\n",
    "7-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8ef488e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Multiplication\n",
    "2*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1570f791",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Division\n",
    "9/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9adff623",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Floor Division\n",
    "9//2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b64680c",
   "metadata": {},
   "source": [
    "The **//** operator (two forward slashes) truncates the decimal without rounding, and returns an integer result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "846df1a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Modulo\n",
    "12%7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ef066ae",
   "metadata": {},
   "source": [
    "The **%** operator returns the remainder after division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "20a7dba5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Power\n",
    "5**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "af042d1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Square Root\n",
    "16**0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1ba3bd6",
   "metadata": {},
   "source": [
    "While we've used the built-in exponentiation operator for square roots, there are more specialized libraries like NumPy that offer efficient functions for mathematical operations. We'll explore NumPy in detail later in the course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "70ef49fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "408.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Order of Operations followed in Python\n",
    "4 + 20 * 20 + 8 / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33a1e10a",
   "metadata": {},
   "source": [
    "Python has a set of rules for the order in which operations are performed. Multiplication and division have higher precedence than addition and subtraction. So, in the expression 4 + 20 * 20 + 8 / 2, the multiplication is done first, resulting in 100. Then, the divisioin is done. Finally, the additions are performed from left to right. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "97a5c216",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "408.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 + (20*20) + (8/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a23144d9",
   "metadata": {},
   "source": [
    "You can use parentheses to specify and change orders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "416772ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "336.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Using parentheses to specify orders\n",
    "(4 + 20) * ((20 + 8) / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c13885ed",
   "metadata": {},
   "source": [
    "<a name='Python_Builtin_Arithmetic_Functions'></a>\n",
    "\n",
    "## 1.3. Python Built-in Arithmetic Functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93415ca6",
   "metadata": {},
   "source": [
    "- **`pow()`**: This function in Python is equivalent to the `**` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4f23ee4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "441f08c7",
   "metadata": {},
   "source": [
    "The `pow()` function accepts an optional third argument that computes the first number raised to the power of the second number, then takes the modulo with respect to the third number. In other words, `pow(x, y, z)` is equivalent to `(x ** y) % z`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5709afd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(2, 3, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "694a176a",
   "metadata": {},
   "source": [
    "- **`round()`**: It rounds a number to the nearest integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ce8ef512",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(3.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b84d8c8",
   "metadata": {},
   "source": [
    "To round a number to a specific number of decimal places, you can utilize the `round()` function and provide a second argument specifying the desired decimal precision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8c567ae3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.236"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(3.2359, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd5e9026",
   "metadata": {},
   "source": [
    "- **`abs()`**: Returns a positive number of the same type as its argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "00f6d4f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-5.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "59422450",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75841e51",
   "metadata": {},
   "source": [
    "<a name='Variable_Assignment'></a>\n",
    "\n",
    "## 1.4. Variable Assignment:\n",
    "\n",
    "Now that we understand how to perform calculations in Python, let's learn about variables and how to assign values to them.\n",
    "\n",
    "A variable in Python is a container that stores a value. It's like a box labeled with a name, and you can put different values inside that box. The name of the variable allows you to refer to the value stored within it.\n",
    "\n",
    "Use the assignment operator (=) to assign a value to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8397f68d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create a variable and assign a value\n",
    "a = 25"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f51cb1da",
   "metadata": {},
   "source": [
    "Now if I call a in my Python script, Python will treat it as the number 25."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "0f13204a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06b1353a",
   "metadata": {},
   "source": [
    "You can use all basic arithmetic operation using variables containing values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "553dd441",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "cf084e24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15664668",
   "metadata": {},
   "source": [
    "Variables can also be assigned like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0dd3725e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "x1, x2, x3 = 4, 5, 6\n",
    "\n",
    "print(x1)\n",
    "print(x2)\n",
    "print(x3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc8892f7",
   "metadata": {},
   "source": [
    "The names you use when creating these labels need to follow a few rules:\n",
    "\n",
    "   - 1. Names can not start with a number.\n",
    "   - 2. There can be no spaces in the name, use _ instead.\n",
    "   - 3. Can't use any of these symbols :'\",<>/?|\\()!@#$%^&*~-+\n",
    "   - 4. It's considered best practice (PEP8) that names are lowercase.\n",
    "   - 5. Avoid using the characters 'l' (lowercase letter el), 'O' (uppercase letter oh), \n",
    "       or 'I' (uppercase letter eye) as single character variable names because these characters \n",
    "       can be easily confused with other characters.\n",
    "   - 6. Avoid using words that have special meaning in Python like \"if\" \"list\" and \"str\"\n",
    "\n",
    "\n",
    "Using variable names can be a very useful way to keep track of different variables in Python. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "af1eb140",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "59999.0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define variables\n",
    "product_price = 599.99\n",
    "quantity_sold = 100\n",
    "\n",
    "#Calculate total revenue\n",
    "total_revenue = product_price * quantity_sold\n",
    "\n",
    "#Result\n",
    "total_revenue"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17178ca0",
   "metadata": {},
   "source": [
    "<a name='Variable_Reassignment'></a>\n",
    "\n",
    "## 1.5. Variable Reassignment\n",
    "\n",
    "In Python, variables can be reassigned to hold different values throughout the execution of a program. This means you can change the value stored in a variable at any time. This feature is also known as **dynamic typing** and it differs from other languages that are statically typed.\n",
    "\n",
    "Pros of Dynamic Typing in Python:\n",
    "\n",
    "- Flexibility: You can easily change the data type of a variable as needed, making your code more adaptable to changing requirements.\n",
    "- Simpler syntax: There's no need for explicit type declarations, which can make your code more concise and easier to read.\n",
    "- Rapid development: Dynamic typing can speed up development, as you don't have to worry about type checking errors.\n",
    "- Prototype development: It's well-suited for prototyping and experimentation, as you can quickly iterate and change the data types without worrying about compatibility issues.\n",
    "\n",
    "Cons of Dynamic Typing in Python:\n",
    "\n",
    "- Potential for runtime errors: While dynamic typing can be convenient, it can also lead to runtime errors if you accidentally assign an incompatible type to a variable.\n",
    "- Reduced performance: In some cases, dynamic typing can lead to slightly slower execution compared to statically typed languages, especially when dealing with large datasets or performance-critical applications.\n",
    "- Debugging challenges: Debugging can be more difficult, as you may need to track the types of variables throughout your code to understand the root cause of errors.\n",
    "- Reduced code readability: In some cases, the lack of explicit type annotations can make it harder to understand the intent of your code, especially for complex data structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b84c053b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "57156f25",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "ef8d2fd2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e6953cd",
   "metadata": {},
   "source": [
    "We can also use the variables themselves when doing the reassignment. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "af25fefa",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = a - 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "fe0f28c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fe2d8cab",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = a + a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e59b5ead",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e393ffe",
   "metadata": {},
   "source": [
    "Some operators combine an arithmetic operation with an assignment, providing a concise way to perform calculations and update variable values in a single step. For example: \n",
    "\n",
    "`+=:` Adds the right-hand operand to the left-hand operand and assigns the result to the left-hand operand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "08891171",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a *= 2\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "20cae399",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a -= 10  #Meaning: a = a + 10\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba175c78",
   "metadata": {},
   "source": [
    "<a name='Determining_Variable_Type'></a>\n",
    "\n",
    "## 1.6. Determining Variable Type:\n",
    "\n",
    "You can check what type of object is assigned to a variable using Python's built-in `type()` function. Common data types include which we will discuss later:\n",
    "* **int** (for integer)\n",
    "* **float**\n",
    "* **str** (for string)\n",
    "* **list**\n",
    "* **tuple**\n",
    "* **dict** (for dictionary)\n",
    "* **set**\n",
    "* **bool** (for Boolean True/False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ba38b63b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3b441715",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d2da4493",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = [1,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "cf891e8e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}