python-basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align:center;\">\n",
    "  <img src=\"images/molssi_main_horizontal.png\" style=\"display: block; margin: 0 auto; max-height:200px;\">\n",
    "</div>\n",
    "\n",
    "# What is Python?\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "Questions:\n",
    "\n",
    "* What is the Python programming language, and what is it used for?\n",
    "\n",
    "* What are the advantages and disadvantages of using Python?\n",
    "\n",
    "* What is a Jupyter notebook?\n",
    "\n",
    "Objectives:\n",
    "\n",
    "* Describe the Python programming language and its uses.\n",
    "\n",
    "* Learn the basics of the Jupyter notebook.\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), 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",
    "Notably, in contrast to some other languages commonly used in scientific programming, Python is **free and open-source**. \n",
    "This means anyone can download, install, and use Python.\n",
    "Python can be used to build web applications, interact with databases, and and to analyze data.\n",
    "\n",
    "\n",
    "## Python in Science\n",
    "\n",
    "Python is used in many different scientific fields, including chemistry, physics, biology, and astronomy.\n",
    "Python is used in scientific programming for a variety of reasons, including:\n",
    "\n",
    "* Python is free and open-source.\n",
    "* Python is easy to learn (compared to compiled programming languages like C++).\n",
    "* Python has a large community of users and developers.\n",
    "\n",
    "The Scientific Python ecosystem is a set of packages commonly used for scientific applications. \n",
    "These packages are the foundation of scientific Python programming across a range of disciplines and include\n",
    "NumPy, SciPy, Matplotlib, and Pandas.\n",
    "In our workshop today, we will explore the basics of these foundational libraries.\n",
    "\n",
    "In chemistry specifically, there are a number of specialized libraries used for processing or analyzing chemical data. \n",
    "For example, there are many libraries for reading and writing chemical file formats, such as the [Open Babel](http://openbabel.org/wiki/Main_Page) library. There are also libraries for cheminformatics, like RDKit, and libraries for quantum chemistry, like Psi4.\n",
    "For experimental chemists, there are libraries for [working with and analyzing NMR spectra](https://github.com/jjhelmus/nmrglue).\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 (text) 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",
    "Markdown is a text markup language that Jupyter formats into nice looking text.\n",
    "In markdown, for example, a first level heading is denoted by\n",
    "\n",
    "```\n",
    "# Heading\n",
    "```\n",
    "\n",
    "Double click inside this cell to see what the markdown cell looks like!\n",
    "Try adding some subheadings (`##`) or bullet points yourself!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Our First Python Code\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": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "3 + 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the cells below to try out some other calculations.\n",
    "\n",
    "When doing calculations in Python, you can use the following operators:\n",
    "\n",
    "* `+` for addition\n",
    "* `-` for subtraction\n",
    "* `*` for multiplication \n",
    "* `/` for division\n",
    "* `**` for exponentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write some code to calculate the result of adding 10 and 55 together.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write some code to calculate the result of subtracting 5 from 100.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write some code to calculate dividing 100 by 4.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write some code to calculate the result of squaring 10.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assigning variables\n",
    "\n",
    "In the cells above, we saw that Python can perform calculations for us. \n",
    "To save our calculated values we can 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 = variable_value\n",
    "```\n",
    "\n",
    "Let’s see this in action with a calculation.\n",
    "Let's define some variables for our calculation.\n",
    "When you run this code, you will not see any output.\n",
    "However, the variables have been assigned values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "deltaH = -541.5   # kJ/mole\n",
    "deltaS =  10.4     # kJ/(mole K)\n",
    "temp = 298      # Kelvin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice several things about this code. \n",
    "The text after `#` are comments. \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",
    "There are a few other things to know about variables in Python:\n",
    "\n",
    "* The variable name must start with a letter or an underscore. Variable names cannot start with a number.\n",
    "* The variable name can only contain letters, numbers, and underscores.\n",
    "* The variable name is case-sensitive. This means that `Temp` and `temp` are different variables.\n",
    "* Variables must be created, or \"defined\", before they can be used. If you try to use a variable that has not been defined, you will get an error.\n",
    "\n",
    "We can now access any of the variables from other cells. Let’s calculate something using our defined variables.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate something with your variables - what might we want to calculate with deltaH, deltaS, and temp?\n",
    "\n",
    "\n",
    "# Put the variable you created as the last thing in the cell to see its value\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "<strong>Check Your Understanding</strong>\n",
    "\n",
    "Write some code below to calculate the pressure of an ideal gas using the ideal gas law.\n",
    "The ideal gas law is given by: PV = nRT, where P is the pressure, V is the volume, n is the number of moles, R is the ideal gas constant, and T is the temperature in Kelvin.   \n",
    "\n",
    "Define Python variable for each term in the ideal gas law and calculate the pressure of an ideal gas at 300 K, 1 L, 1 mol, and R = 0.0821 L atm / (mol K).\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write some code to calculate the pressure. To see the result, put your pressure variable in the last line of the cell.\n",
    "# Name your final variable pressure.\n",
    "\n",
    "\n",
    "# Put the variable you created as the last thing in the cell to see its value\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JupyterLab: The `tab` key\n",
    "\n",
    "Jupyter notebooks allow autocomplete using the tab key.\n",
    "To test this out, try typing `pri` in the cell below, then press `tab` on your keyboard twice.\n",
    "You should see that the word `print` is completed for you.\n",
    "\n",
    "After you have the word `print` add a parenthesis, then start typing `delt` and press `tab` twice again.\n",
    "You will see a list of potential variables or functions you might want to use. \n",
    "You can use the arrows + the Enter key to select the variable you would like to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Functions\n",
    "\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",
    "A function might perform a calculation and give us the calculated value. This is called the return value of the function.\n",
    "We can assign the return value of a function to a variable.\n",
    "\n",
    "```python\n",
    "variable_name = function_name(argument1, argument2)\n",
    "```\n",
    "\n",
    "For example, if we think about our calculations above, we might decide that our results have too many decimal places.\n",
    "We can use the `round` function to round our results to a certain number of decimal places.\n",
    "\n",
    "The round function takes in the number you want to round and the number of decimal places you want to round to.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pressure = 2.3456\n",
    "\n",
    "# Use the round function to round pressure to two decimal places. Put the result in a new variable called rounded_pressure.  \n",
    "rounded_pressure = round(pressure, 2)\n",
    "\n",
    "# Put rounded_pressure in the last line of the cell to see its value.\n",
    "rounded_pressure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "## Saving New Values\n",
    "Notice in our previous code block that we saved the rounded value of pressure by assigning it to a new variable called `rounded_pressure`.\n",
    "When we did this, we saved the value of the rounded pressure for later use.\n",
    "Notice that in Python, just calling a function or performing a calculation with a variable does not save the result or overwrite the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(pressure)\n",
    "round(pressure,2)\n",
    "print(pressure)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(pressure)\n",
    "pressure = round(pressure,2)\n",
    "print(pressure)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can see that we have changed the value of `pressure` to the rounded value of `pressure`.   \n",
    "Is this really what we wanted to do?\n",
    "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": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "<strong>Check Your Understanding</strong>\n",
    "\n",
    "Round your deltaG calculation to 2 decimal places and print it out.\n",
    "\n",
    "Should you save your rounded value to a new variable or overwrite the existing variable?\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types\n",
    "\n",
    "When working with computers and programming languages, the concept of a data type is very important.\n",
    "A data type is a classification that specifies which type of value a variable can hold.\n",
    "A human can tell the difference between the number 1 and the word \"one\", but a computer needs to know the difference between these two things.\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": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "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.\n",
    "Lists are a default data type in Python - meaning they are always available no matter what libraries you are using.\n",
    "\n",
    "You can visualize a list using the illustration below.\n",
    "In our picture, our list has 6 elements. \n",
    "**Notably for Python, when counting elements in a list, you start at 0.**\n",
    "\n",
    "![list_index](images/list_index.png)\n",
    "\n",
    "Lists are created by adding square brackets around a value or variable.\n",
    "List elements are separated by commas. \n",
    "Python has several built in functions which can be used on lists. \n",
    "The function `len` can be used to determine the length of a list.\n",
    "The `max` function can be used to find the maximum value in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# I make a list with square brackets and values separated by commas\n",
    "energy_kcal = [-13.4, -2.7, 5.4, 42.1]\n",
    "\n",
    "# I can measure the length of the list using the len() function\n",
    "energy_length = len(energy_kcal)\n",
    "\n",
    "# I can measure the maximum value of the list using the max() function\n",
    "max_energy = max(energy_kcal)\n",
    "\n",
    "# print calculated values\n",
    "print('The length of this list is', energy_length)\n",
    "print('The maximum of the energy values is', max_energy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "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": null,
   "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": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "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=\"alert alert-block alert-warning\">\n",
    "    \n",
    "### Check Your Understanding\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",
    "See if you can predict the output, then check yourself in the cells below.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": null,
   "metadata": {},
   "outputs": [],
   "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.\n",
    "\n",
    "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",
    "To define what happens if the `if` statement is not met, you can use the `else` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "negative_numbers = []\n",
    "positive_numbers = []\n",
    "for number in energy_kJ:\n",
    "    ## Add code here to check if the number is negative\n",
    "    print(number)\n",
    "\n",
    "print(\"Negative numbers:\", negative_numbers)\n",
    "print(\"Positive Numbers: \", positive_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "\n",
    "### Final Challenge\n",
    "\n",
    "Calculate ∆G for a reation with ∆H=1.52 kJ/mol and ∆S=5.1 J/K mol for 100 K, 150 K, 200 K, 250 K, 300 K, 350 K, and 400 K. \n",
    "You should create two lists: one with ∆G values and one with temperatures for which the reaction is spontaneous.\n",
    "Save the ∆G values in a list called `deltaG_list` and the temperatures for which the reaction is spontaneous in a list called `spontaneous_temp_list`.\n",
    "\n",
    "Steps:\n",
    "* Define a list of temperatures\n",
    "* Create empty lists called `spontaneous_temp_list` and `deltaG_list`\n",
    "* Use a for loop to calculate ∆G for each temperature.\n",
    "\n",
    "**Make sure you pay attention to units**\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Your code for the final challenge here!\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}