00-python-basics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       " <meta charset=\"utf-8\" />\n",
       "    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" /><meta name=\"generator\" content=\"Docutils 0.19: https://docutils.sourceforge.io/\" />\n",
       "\n",
       "    <link rel=\"stylesheet\" type=\"text/css\" href=\"custom/custom.css\" />\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# apply Jupyter notebook style\n",
    "from IPython.core.display import HTML\n",
    "\n",
    "from custom.styles import style_string\n",
    "\n",
    "HTML(style_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "<div style=\"text-align:center;\">\n",
    "  <img src=\"custom/molssi_main_horizontal.png\" style=\"display: block; margin: 0 auto; max-height:200px;\">\n",
    "</div>\n",
    "\n",
    "# Introduction to Python\n",
    "\n",
    "<div class=\"overview admonition\"> \n",
    "<p class=\"admonition-title\">Overview</p>\n",
    "\n",
    "Questions:\n",
    "\n",
    "* What is the Python programming language, and what is it used for?\n",
    "\n",
    "* What is the basic syntax of the Python programming language?\n",
    "    \n",
    "* What is a Python list?\n",
    "    \n",
    "* What is a Python dictionary?\n",
    "    \n",
    "* What is a `for` loop?\n",
    "\n",
    "Objectives:\n",
    "\n",
    "* Assign values to variables.\n",
    "\n",
    "* Use the `print` function to check how the code is working.\n",
    "    \n",
    "* Use a `for` loop to perform the same action on all the items in a list.\n",
    "    \n",
    "* Use the append function to create new lists in `for` loops.\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Python and why use it?\n",
    "\n",
    "All of the software you use on a regular basis is created through the use of programming languages. \n",
    "Programming languages allow us to write instructions to a computer. \n",
    "There are many different programming languages, each with their own strengths, weaknesses, and uses. \n",
    "Some popular programming languages you might hear about are Javascript (used on the web - any website with interactive content likely uses javascript), Python (scientific programming and many other applications), C++ (high performance applications - much of computational chemistry, self-driving cars, etc), SQL (databases), and many more.\n",
    "\n",
    "Python is a computer programming language that has become ubiquitous in scientific programming. \n",
    "The Python programming language was first introduced in the year 1991, and has grown to be one of the most popular programming languages for both scientists and non-scientists. \n",
    "According to the [2022 Stack Overflow Developer Survey](https://survey.stackoverflow.co/2022/#most-popular-technologies-language-prof), Python is the fourth most popular programming language.\n",
    "Compared to other programming languages, Python is considered more intutitive to start learning and is also extremely versatile. \n",
    "Python can be used to build web applications, interact with databases, and calculate and analyze data.\n",
    "Python also has many libraries focused on science and machine learning.\n",
    "\n",
    "In computational chemistry, we will see that we can use Python to run and analyze our simulations. \n",
    "We can also use some of Python's many libraries to fit data and predict properties.\n",
    "\n",
    "## Getting Started\n",
    "\n",
    "Our initial lessons will run python interactively through a Python interpreter. \n",
    "We will use an environment called a Jupyter notebook. \n",
    "The Jupyter notebook is an environment in your browser that can be used to write an execute Python code interactively.\n",
    "You can view a Jupyter notebook using your browser or in some specialized text editors.\n",
    "\n",
    "Jupyter notebooks are made up of cells. Cells can either be markdown or code cells.\n",
    "This cell is a Markdown Cell.\n",
    "Code cells have executable Python code in them.\n",
    "To change the type of a cell you can use the drop down option in the top window.\n",
    "To run code in a cell, click inside of the cell and press `Shift+Enter`.\n",
    "If the code executes successfully, the next cell will become the active cell.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assigning variables\n",
    "\n",
    "Any Python interpreter can work just like a calculator. \n",
    "This is not very useful. \n",
    "Press the Shift Key and the Enter Key (`Shift + Enter`) at the same time to run (also called \"execute\") the code in a cell.\n",
    "The following cell contains an expression to calculate `3 + 7`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, Python has performed a calculation for us. To save this value, or other values, we assign them to a variable for later use. \n",
    "Variable **assignment** is the technical term for doing this. \n",
    "If we do not assign an expression to a variable, we will not be able to use its value later.\n",
    "\n",
    "The syntax for assigning variables is the following:\n",
    "\n",
    "```python\n",
    "variable_name = varaible_value\n",
    "```\n",
    "\n",
    "Let’s see this in action with a calculation.\n",
    "Let's define some variables for our calculation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "deltaH = -541.5   #kJ/mole\n",
    "deltaS =  10.4     #kJ/(mole K)\n",
    "temp = 298      #Kelvin\n",
    "deltaG = deltaH - temp * deltaS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice several things about this code. \n",
    "The lines that begin with # are comment lines. \n",
    "The computer does not do anything with these comments. \n",
    "They have been used here to remind the user what units each of their values are in. \n",
    "Comments are also often used to explain what the code is doing or leave information for future people who might use the code.\n",
    "\n",
    "When choosing variable names, you should choose informative names so that someone reading your code can tell what they represent. Naming a variable temp or temperature is much more informative than naming that variable t.\n",
    "\n",
    "We can now access any of the variables from other cells. Let’s print the value that we calculated.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3640.7000000000003\n"
     ]
    }
   ],
   "source": [
    "print(deltaG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Functions\n",
    "\n",
    "When we use `print`, we are using a `function`. \n",
    "Functions are reusable pieces of code that perform certain tasks. \n",
    "Examples include printing, opening files, performing a calculations, and many others.\n",
    "Functions have a name that is followed by parenthesis containing the function inputs separated by commas (also called *arguments*).\n",
    "\n",
    "```python\n",
    "function_name(argument1, argument2)\n",
    "```\n",
    "\n",
    "In the previous code block, we introduced the `print` function. Often, we will use the print function just to make sure our code is working correctly.\n",
    "\n",
    "Note that if you do not specify a new name for a variable, then it doesn’t automatically change the value of the variable. For example if we typed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3640.7000000000003\n",
      "-3640.7000000000003\n"
     ]
    }
   ],
   "source": [
    "print(deltaG)\n",
    "deltaG * 1000\n",
    "print(deltaG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nothing happened to the value of deltaG. If we wanted to change the value of deltaG we would have to re-save the variable using the same name to overwrite the existing value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3640.7000000000003\n",
      "-3640700.0000000005\n"
     ]
    }
   ],
   "source": [
    "print(deltaG)\n",
    "deltaG = deltaG * 1000\n",
    "print(deltaG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are situations where it is reasonable to overwrite a variable with a new value, but you should always think carefully about this. Usually it is a better practice to give the variable a new name and leave the existing variable as is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3640700.0000000005\n",
      "-3640700.0000000005\n",
      "-3640700000.0000005\n"
     ]
    }
   ],
   "source": [
    "print(deltaG)\n",
    "deltaG_joules = deltaG * 1000\n",
    "print(deltaG)\n",
    "print(deltaG_joules)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types\n",
    "\n",
    "Each variable is some particular type of data. \n",
    "The most common types of data are strings (str), \n",
    "integers (int), and floating point numbers (float).\n",
    "You can identify the data type of any variable with the function `type(variable_name)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(deltaG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change the data type of a variable like this. This is called casting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deltaG_string = str(deltaG)\n",
    "type(deltaG_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could have created a variable as a string originally by surrounding the value in quotes `\"\"`. It doesn't matter if you use single or double quotes, the first quote just has to match the closing quote."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "string_variable = \"This is a string\"\n",
    "print(type(string_variable))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Another common data structure in python is the list. Lists can be used to group several values or variables together, and are declared using square brackets `[ ]`. \n",
    "List values are separated by commas. \n",
    "Python has several built in functions which can be used on lists. \n",
    "The built-in function `len` can be used to determine the length of a list.\n",
    "This code block also demonstrates how to print multiple variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of this list is 4\n"
     ]
    }
   ],
   "source": [
    "# This is a list\n",
    "energy_kcal = [-13.4, -2.7, 5.4, 42.1]\n",
    "# I can determine its length\n",
    "energy_length = len(energy_kcal)\n",
    "\n",
    "# print the list length\n",
    "print('The length of this list is', energy_length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If I want to operate on a particular element of the list, you use the list name and then put in brackets which element of the list you want. In python counting starts at zero. So the first element of the list is list[0]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-13.4\n"
     ]
    }
   ],
   "source": [
    "# Print the first element of the list\n",
    "print(energy_kcal[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use an element of a list as a variable in a calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-11.296800000000001\n"
     ]
    }
   ],
   "source": [
    "# Convert the second list element to kilojoules.\n",
    "energy_kilojoules = energy_kcal[1] * 4.184\n",
    "print(energy_kilojoules)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slices\n",
    "\n",
    "Sometimes you will want to make a new list that is a subset of an existing list. For example, we might want to make a new list that is just the first few elements of our previous list. This is called a slice. The general syntax is\n",
    "\n",
    "```python\n",
    "new_list = list_name[start:end]\n",
    "```\n",
    "\n",
    "When taking a slice, it is very important to remember how counting works in python. Remember that counting starts at zero so the first element of a list is `list_name[0]`. When you specify the last element for the slice, it goes *up to but not including* that element of the list. So a slice like\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "short_list = energy_kcal[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "includes energy_kcal[0] and energy_kcal[1] but not energy_kcal[2].\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-13.4, -2.7]\n"
     ]
    }
   ],
   "source": [
    "print(short_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you do not include a start index, the slice automatically starts at list_name[0]. If you do not include an end index, the slice automatically goes to the end of the list.\n",
    "\n",
    "\n",
    "<div class=\"exercise admonition\">\n",
    "<p class=\"admonition-title\">Check Your Understanding</p>\n",
    "\n",
    "What does the following code block print?\n",
    "```python\n",
    "slice1 = energy_kcal[1:]\n",
    "slice2 = energy_kcal[:3]\n",
    "print('slice1 is', slice1)\n",
    "print('slice2 is', slice2)\n",
    "```\n",
    "\n",
    "<div class=\"solution admonition dropdown\">\n",
    "<p class=\"admonition-title\">Solution</p>\n",
    "\n",
    "The code prints\n",
    "\n",
    "```output\n",
    "slice1 is [-2.7, 5.4, 42.1]\n",
    "slice2 is [-13.4, -2.7, 5.4]\n",
    "```\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repeating an operation many times: for loops\n",
    "\n",
    "Often, you will want to do something to every element of a list. The structure to do this is called a for loop. The general structure of a for loop is\n",
    "\n",
    "```python\n",
    "\n",
    "for variable in list:\n",
    "    do things using variable\n",
    "\n",
    "```\n",
    "\n",
    "There are two very important pieces of syntax for the for loop. Notice the colon : after the word list. You will always have a colon at the end of a for statement. If you forget the colon, you will get an error when you try to run your code.\n",
    "\n",
    "The second thing to notice is that the lines of code under the for loop (the things you want to do several times) are indented. Indentation is very important in python. There is nothing like an end or exit statement that tells you that you are finished with the loop. The indentation shows you what statements are in the loop. Each indentation is 4 spaces by convention in Python 3. However, if you are using an editor which understands Python, it will do the correct indentation for you when you press the tab key on your keyboard. In fact, the Jupyter notebook will notice that you used a colon (`:`) in the previous line, and will indent for you (so you will not need to press tab).\n",
    "\n",
    "Let’s use a loop to change all of our energies in kcal to kJ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-56.0656\n",
      "-11.296800000000001\n",
      "22.593600000000002\n",
      "176.1464\n"
     ]
    }
   ],
   "source": [
    "for number in energy_kcal:\n",
    "    kJ = number * 4.184\n",
    "    print(kJ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it seems like we are really getting somewhere with our program! But it would be even better if instead of just printing the values, it saved them in a new list. To do this, we are going to use the append function. The append function adds a new item to the end of an existing list. The general form of the append function is\n",
    "\n",
    "```python\n",
    "list_name.append(new_thing)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'energy_kJ' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[16], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m number \u001b[38;5;129;01min\u001b[39;00m energy_kcal:\n\u001b[1;32m      2\u001b[0m     kJ \u001b[38;5;241m=\u001b[39m number \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m4.184\u001b[39m\n\u001b[0;32m----> 3\u001b[0m     \u001b[43menergy_kJ\u001b[49m\u001b[38;5;241m.\u001b[39mappend(kJ)\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(energy_kJ)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'energy_kJ' is not defined"
     ]
    }
   ],
   "source": [
    "\n",
    "for number in energy_kcal:\n",
    "    kJ = number * 4.184\n",
    "    energy_kJ.append(kJ)\n",
    "\n",
    "print(energy_kJ)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an example of an error message. An error message is what occurs if there is something wrong with your code. \n",
    "In Python, when you read error messagees, you should try to read the last line of the error message first. \n",
    "It will have a message about what went wrong in the program execution.\n",
    "\n",
    "This code doesn’t work because on the first iteration of our loop, the list energy_kJ doesn’t exist. To make it work, we have to start the list outside of the loop. The list can be blank when we start it, but we have to start it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-56.0656, -11.296800000000001, 22.593600000000002, 176.1464]\n"
     ]
    }
   ],
   "source": [
    "energy_kJ = []\n",
    "for number in energy_kcal:\n",
    "    kJ = number * 4.184\n",
    "    energy_kJ.append(kJ)\n",
    "\n",
    "print(energy_kJ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making choices: logic statements\n",
    "\n",
    "Within your code, you may need to evaluate a variable and then do something if the variable has a particular value. This type of logic is handled by an if statement. In the following example, we only append the negative numbers to a new list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-56.0656, -11.296800000000001]\n"
     ]
    }
   ],
   "source": [
    "negative_energy_kJ = []\n",
    "\n",
    "for number in energy_kJ:\n",
    "    if number < 0:\n",
    "        negative_energy_kJ.append(number)\n",
    "\n",
    "print(negative_energy_kJ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other logic operations include\n",
    "\n",
    "* equal to `==`\n",
    "* not equal to `!=`\n",
    "* greater than `>`\n",
    "* less than `<`\n",
    "* greater than or equal to `>=`\n",
    "* less than or equal to `<=`\n",
    "\n",
    "You can also use and, or, and not to check more than one condition.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-56.0656, -11.296800000000001]\n"
     ]
    }
   ],
   "source": [
    "negative_numbers = []\n",
    "for number in energy_kJ:\n",
    "    if number < 0 or number == 0:\n",
    "        negative_numbers.append(number)\n",
    "\n",
    "print(negative_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To define what happens if the `if` statement is not met, you can use the `else` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Negative numbers: [-56.0656, -11.296800000000001]\n",
      "Positive Numbers:  [22.593600000000002, 176.1464]\n"
     ]
    }
   ],
   "source": [
    "negative_numbers = []\n",
    "positive_numbers = []\n",
    "for number in energy_kJ:\n",
    "    if number < 0 or number == 0:\n",
    "        negative_numbers.append(number)\n",
    "    else:\n",
    "        positive_numbers.append(number)\n",
    "\n",
    "print(\"Negative numbers:\", negative_numbers)\n",
    "print(\"Positive Numbers: \", positive_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"exercise admonition\">\n",
    "<p class=\"admonition-title\">Check Your Understanding</p>\n",
    "<p>The following cell contains a list with some floating point numbers and some numbers which have been saved as strings. Copy this list exactly into your code.</p>\n",
    "    \n",
    "<p>Set up a `for` loop to go over each element of `data_list`. If the element is a string (`str`), recast it as a float. Save the numbers that are greater than 0 to a new list.<p>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data_list = ['-12.5', 14.4, 8.1, '42', '-100']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[14.4, 8.1, 42.0]\n"
     ]
    }
   ],
   "source": [
    "greater_than_zero = []\n",
    "\n",
    "for data in data_list:\n",
    "    if type(data) == str:\n",
    "        data = float(data)\n",
    "\n",
    "    if data > 0:\n",
    "        greater_than_zero.append(data)\n",
    "\n",
    "print(greater_than_zero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.10.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "16d4a7bb199d969b1271ebe46f77414b0d9cd01b3c3983c2b2742fc6cd4503d3"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}