tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Scripting and Data Processing Tutorial\n",
    "Python is a multi-purpose programming language that is useful for a wide variety of applications, in particular it has become very. \n",
    "One way to use Python in interactively in a Jupyter Notebook as we are using it here.\n",
    "Python is run through the Python interpreter, which takes and runs the code in the notebook cell by cell.\n",
    "To run a the current cell, press `shift+enter`.\n",
    "These examples are largely based on the [MOLSSI Python Tutorials](https://education.molssi.org/python_scripting_cms/01-introduction/index.html) created by Ashley Ringer-McDonald.\n",
    "This notebook is meant to be worked through interactively, to start run the cell below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Variables and Data Types\n",
    "\n",
    "In Python variables store a values and are declared in the form:\n",
    "\n",
    "```Python\n",
    "variable_name = variable_value\n",
    "```\n",
    "\n",
    "The value is then saved to that variable name can then be referenced later.\n",
    "\n",
    "Variable values are categorized by data type, which describes what the variable is.\n",
    "In Python there are three basic data types integers, floats and booleans, which are sometimes called primitive types.\n",
    "- Integers are whole numbers without a decimal, and can be positive or negative, for example `x = -3`.\n",
    "- Floating point values or floats are numerical values with decimals, and can also be declared in scientific notation, ex: `T = 346.1` or `dH = 1.56e5` where the number following `e` is raised to the power of 10.\n",
    "- Booleans are the logical values `True` and `False`, and come into play more when discussing control flow.\n",
    "When declaring a variable in Python the data type can be specified with a \"type hint\", which indicates to users and the interpreter what data type the variable is.\n",
    "\n",
    "The syntax for a type signature is:\n",
    "\n",
    "```Python\n",
    "variable_name: variable_type = variable_value\n",
    "```\n",
    "\n",
    "These are not required, but help to make code more readable.\n",
    "\n",
    "### Using Variables\n",
    "\n",
    "The code cells below illustrate a few examples of using variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "541.5\n"
     ]
    }
   ],
   "source": [
    "deltaH: float = 5.415e2 # kJ/mol\n",
    "print(deltaH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A few thinks to note about this cell: first, comments are denoted with `#`, and we can use the `print()` function to output information. Printing variables is often a useful was to understand what your code is doing.\n",
    "\n",
    "Next lets look at some calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3640.7000000000003\n"
     ]
    }
   ],
   "source": [
    "deltaH: float = -541.5   #kJ/mole\n",
    "deltaS: float =  10.4     #kJ/(mole K)\n",
    "temp: int = 298      #Kelvin\n",
    "deltaG: float = deltaH - temp * deltaS\n",
    "\n",
    "print(deltaG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this cell we can see some math operations used, and the result assigned to the variable `deltaG`.\n",
    "An additional detail illustrates how data types work in Python.\n",
    "When `temp` is declared it is an integer, since it has not decimal point, but when it is used to calculate `deltaG` the result is a floating point value.\n",
    "This is because math operations can accept integers and floats interchangeably, and returns a floating point value.\n",
    "The next example illustrates this more directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is an <class 'float'>\n",
      "y is an <class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x: float = 1.1\n",
    "y: int = 2\n",
    "print(f\"x is an {type(x)}\")\n",
    "print(f\"y is an {type(y)}\")\n",
    "print(type(x * y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `type()` returns the type of a variable, and as we can see multiplying an int with a float returns a float.\n",
    "\n",
    "Next lets look at a few more examples of variables behavior of  in python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "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": [
    "This example illustrates two ideas:\n",
    "- variables persist between cell in a notebook\n",
    "- if the value of an operation is assigned a variable name the value does not change\n",
    "\n",
    "If we wanted to save the result of that calculation, we would have to overwrite the previous value of the variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "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": [
    "In most situations you may want both values, in that case create a new variable to store the value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(deltaG)\n",
    "deltaG_joules = deltaG * 1000\n",
    "print(deltaG)\n",
    "print(deltaG_joules)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to assign several variables at once, this is sometimes done for the sake of compactness."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3640.7000000000003\n"
     ]
    }
   ],
   "source": [
    "#I can assign all these variables at once\n",
    "deltaH, deltaS, temp = -541.5, 10.4, 298\n",
    "deltaG = deltaH - temp * deltaS\n",
    "print(deltaG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Composite Data Types\n",
    "\n",
    "We have previously discussed the primitive data types, which represent a single value.\n",
    "This is not the only kind of data type in Python, or in programming languages more generally.\n",
    "Beyond primitive types, there are composite types (also known as compound or complex types) which contain several primitive values in a singe variable.\n",
    "Since every other data type in Python is a composite type, it would not make sense to enumerate them all below.\n",
    "We'll go into two important ones, lists and strings, in the subsequent sections.\n",
    "\n",
    "### Lists\n",
    "\n",
    "Lists in Python group several variables or values together.\n",
    "They are declared using square brackets `[]` and the values are separated by commas.\n",
    "The function `len()` returns the number of items in a list.\n",
    "The following code block demonstrates declaring a list and printing its length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "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",
    "\n",
    "# print the list length\n",
    "print('The length of this list is', len(energy_kcal))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accessing a particular values of a list, a process called *indexing*, is done by placing square brackets with the item number you want after the list name. \n",
    "In Python counting starts at 0, so the first element of the list is `list[0]`.\n",
    "\n",
    "#### Exercise\n",
    "In the cell below assign the variable `temp2` the second element of the list `temps` by indexing `temps`.\n",
    "\n",
    "\n",
    "<details><summary>Answer</summary>\n",
    "\n",
    "```python\n",
    "temp2 = temps[1]\n",
    "```\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temps = [78.1, 64.3, 98.7]\n",
    "\n",
    "# Add your code here\n",
    "temp2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets go over a few more details about lists.\n",
    "- List can be printed to see their elements\n",
    "- Like with variables, individual list elements can be updated\n",
    "- List elements can also be used in calculations without overwriting them\n",
    "- New values can be added to to list with the syntax `list.append(value)`\n",
    "- In Python, lists can store elements of any data type\n",
    "\n",
    "The next example will use these facts about lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the original list is [-13.4, -2.7, 5.4, 42.1]\n",
      "now the list is [-12.4, -2.7, 5.4, 42.1, True]\n"
     ]
    }
   ],
   "source": [
    "energy_kcal = [-13.4, -2.7, 5.4, 42.1]\n",
    "\n",
    "print(f\"the original list is {energy_kcal}\")\n",
    "\n",
    "# Adding one to the first list value\n",
    "energy_kcal[0] = energy_kcal[0] + 1\n",
    "\n",
    "# Appending a new value to the list\n",
    "\n",
    "energy_kcal.append(True)\n",
    "print(f\"now the list is {energy_kcal}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Slicing\n",
    "\n",
    "Often you'll need some subset of a list, for example we might want just the first few elements of the previous list.\n",
    "This is called a *slice*.\n",
    "The syntax for slicing a list is:\n",
    "\n",
    "```python\n",
    "new_list = list_name[start:end]\n",
    "```\n",
    "\n",
    "It is important to note that in Python **Slices go up to but do not include the `end` element**\n",
    "So the slice `short_list = list_name[0:2]` includes `list_name[0]` and `list_name[1]` but not `list_name[2]`.\n",
    "\n",
    "#### Exercise \n",
    "In the next cell create a new list containing the first 3 elements of the list `masses`.\n",
    "\n",
    "```python\n",
    "    masses = [15.998, 1.01, 14.01, 12.01]\n",
    "```\n",
    "\n",
    "<details><summary>Answer</summary>\n",
    "\n",
    "`new_masses = masses[:4]`\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings\n",
    "\n",
    "Strings are a composite data type in Python that stores text.\n",
    "A string can be declared with either single quotes (`'`) or double quotes (`\"`).\n",
    "Strings are indexed and sliced in the same way as lists.\n",
    "\n",
    "#### Exercise\n",
    "\n",
    "In the next cell capitalize the first character in the string `hello`.\n",
    "\n",
    "```python\n",
    "    hello: str = \"hello world\"\n",
    "```\n",
    "\n",
    "Afterwards create a new string, `word` containing the first word of `hello` by slicing it.\n",
    "\n",
    "<details><summary>Answer</summary>\n",
    "\n",
    "```python\n",
    "    hello: str = \"hello world\"\n",
    "    \n",
    "    hello[0] = 'H'\n",
    "    word = hello[:6]\n",
    "```\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type Casting\n",
    "\n",
    "It is important to note that the string `'1'` in not the same as the integer `1`. This is because the first is the character 1 and the second represents the number 1.\n",
    "Lets try adding them together and see what happens, don't panic when you see an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[26], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m txt_1: \u001b[39mstr\u001b[39m \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39m1\u001b[39m\u001b[39m'\u001b[39m\n\u001b[1;32m      2\u001b[0m num_1: \u001b[39mint\u001b[39m \u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[0;32m----> 4\u001b[0m num_1  \u001b[39m+\u001b[39;49m txt_1\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "txt_1: str = '1'\n",
    "num_1: int = 1\n",
    "\n",
    "num_1  + txt_1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we do this, Python gives us a `TypeError`.\n",
    "This indicates that the data types used in a process are not compatible.\n",
    "This is because you cannot add one to text.\n",
    "\n",
    "If we want to add a number from a string to a numerical value, we need to preform a type cast.\n",
    "This transforms the string into a numerical type.\n",
    "The syntax for type casting is shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(txt_1) + num_1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow\n",
    "\n",
    "Ordinarily, code is run line by line, from the top of the cell to the bottom of the cell.\n",
    "Controlling how code executes is called control flow.\n",
    "In this section we'll go over the main ways to control how code executes.\n",
    "\n",
    "### Repeating an operation many times: for loops\n",
    "\n",
    "Lets say we have a list of temperatures values in Celsius, and want to convert them to Kelvin.\n",
    "We could go through each element and add the 273.15 to convert it like this:\n",
    "\n",
    "```python\n",
    "    temps = [37.5, 22.3, 45.8]\n",
    "    temps_k = []\n",
    "\n",
    "    temps_k.append(temps[0] + 273.15)\n",
    "    temps_k.append(temps[1] + 273.15)\n",
    "    temps_k.append(temps[2] + 273.15)\n",
    "```\n",
    "\n",
    "This obviously is impractical, as each a new line is needed for each additional element of the list.\n",
    "A `for` loop lets us repeat a section of code.\n",
    "The basic structure of a `for` loop based on the example above, where we want to alter each element of a list is:\n",
    "\n",
    "```python\n",
    "    for variable in list:\n",
    "        do stuff to variable\n",
    "```\n",
    "\n",
    "There are a few important things to note about `for` loops:\n",
    "- A colon `:` is required at the end of every for statement\n",
    "- Python uses indentations to denote that code is repeated inside the loop, this is inputted with the **tab** key\n",
    "\n",
    "Lets write a for loop based on the unit conversion example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37.5\n",
      "22.3\n",
      "45.8\n",
      "Temps in kelvin [310.65, 295.45, 318.95]\n"
     ]
    }
   ],
   "source": [
    "temps = [37.5, 22.3, 45.8]\n",
    "temps_k = []\n",
    "\n",
    "for number in temps:\n",
    "    print(number)\n",
    "    temps_k.append(number + 273.15)\n",
    "\n",
    "print(f\"Temps in kelvin {temps_k}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making choices: logic Statements\n",
    "\n",
    "Within code, you have to preform different operations on a variable based on its value.\n",
    "This is handled by an `if` statement.\n",
    "The `if` statement allows for conditional execution of code.\n",
    "Lets look at a simple example below\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3, -7]\n"
     ]
    }
   ],
   "source": [
    "nums = [5, -3, 2, 1, -7]\n",
    "negs = []\n",
    "\n",
    "for num in nums:\n",
    "    if num < 0:\n",
    "        negs.append(num)\n",
    "\n",
    "print(negs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `if` statement works by evaluating a logical statement, and if it is true, executes the indented code following the `if` statement.\n",
    "There are several logical operations in Python:\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",
    "Finally, we come back to the last primitive type, booleans.\n",
    "As previously stated, booleans are logical values, either `True` or `False`.\n",
    "When these logical operations are used, they return a boolean value for example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(1 == 1)\n",
    "print(1 == 2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple logical statements can be put together with `and` and `or`.\n",
    "The `and` operator returns `True` only if both sides of the statement are true.\n",
    "The `or` operator returns `True` if one or both sides of the operator are true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True and True:  False\n",
      "True and False:  False\n",
      "False and False:  False\n",
      "True or True:  True\n",
      "True or False:  True\n",
      "False or False:  False\n"
     ]
    }
   ],
   "source": [
    "print(\"True and True: \", True and False)\n",
    "print(\"True and False: \", True and False)\n",
    "print(\"False and False: \", False and False)\n",
    "print(\"True or True: \", True or True)\n",
    "print(\"True or False: \", True or False)\n",
    "print(\"False or False: \", False or False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally there is the `not` operator, which returns the opposite of the given logical value.\n",
    "\n",
    "These logical operations, paired with `if` statements, let us control specifically what code is run.\n",
    "Lets look at a few examples in the following cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first loop\n",
      "-1\n",
      "-11\n",
      "0\n",
      "second loop\n",
      "5\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "nums = [14, 9 -4, 2, -1, -11, 0, 12, 17]\n",
    "\n",
    "print(\"first loop\")\n",
    "for num in nums:\n",
    "    if num < 0 or num == 0:\n",
    "        print(num)\n",
    "\n",
    "print(\"second loop\")\n",
    "for num in nums:\n",
    "    if num - 2 > 0 and num + 1 < 14:\n",
    "        print(num)\n",
    " \n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing Functions\n",
    "\n",
    "Functions give us a way to organize code into a blocks that preform a specific task.\n",
    "This has multiple benefits\n",
    "- It organizes code into more understandable segments\n",
    "- It makes code modular, letting us reuse the code for a process\n",
    "- It makes code more testable\n",
    "\n",
    "In Python, the following syntax for defining a function:\n",
    "\n",
    "```python\n",
    "    def function_name(parameter: parameter_type) -> return_type:\n",
    "        * function code *\n",
    "        return value_to_return\n",
    "```\n",
    "\n",
    "We define a function using the `def` keyword, followed by the function's name.\n",
    "This name is used to refer to that function later in the body of the code.\n",
    "After the name, the function's parameters are given, functions have no limit to the number of parameters.\n",
    "The parameter's type can optionally be given as well, with a colon `:` used to separate the parameter name from the type.\n",
    "After the parameters the functions return type can optionally be given using `->` followed by the data type name, and a colon `:`.\n",
    "Giving the parameter and return data types is optional, but it helps make the code easier to understand, and prevents you from getting a `TypeError` when the wrong parameter type is given.\n",
    "It is important to not that defining a function does not run it.\n",
    "\n",
    "Lets look at an example where defining a function is helpful.\n",
    "In the next cell we have a list of temperature measurements in Fahrenheit called `temps_f`.\n",
    "We can define a function called `fah_to_c` to make this easier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 100.0, 12.333333333333336]\n"
     ]
    }
   ],
   "source": [
    "def fah_to_c(temp:float) -> float:\n",
    "    temp_c: float = (temp - 32) * 5/9\n",
    "    return temp_c\n",
    "\n",
    "fah_temps = [32.0, 212.0, 54.2]\n",
    "c_temps = []\n",
    "for temp in fah_temps:\n",
    "    c_temps.append(fah_to_c(temp))\n",
    "\n",
    "print(c_temps)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the Fahrenheit to Celsius conversion is simple, this is a very short function.\n",
    "It could easily be done in a `for` loop without making a function, but as processes get more complex, defining a function will help simplify your code.\n",
    "\n",
    "Lets look at a few other features of functions in Python, default values for parameters, and returning multiple values.\n",
    "A default parameter value in Python lets you give a standard value that can still be overwritten.\n",
    "The syntax for adding a default parameter is an equals sign `=` after the parameter name and type (if you give types for parameters).\n",
    "Multiple values can also be returned just by listing multiple variables in after `return` on the last line of the function.\n",
    "Lets look at a quick example of a function `in_between` that takes a list, and two values, and returns the number of list elements in-between those values, and a list of those elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, [3, 2])\n"
     ]
    }
   ],
   "source": [
    "def in_between(numbers, lower=1, upper=4):\n",
    "    between = []\n",
    "    count = 0\n",
    "\n",
    "    for num in numbers:\n",
    "        if num > lower and num < upper:\n",
    "            count = count + 1\n",
    "            between.append(num)\n",
    "    return count, between\n",
    "\n",
    "bet_test = [3, 2, 0, 5]\n",
    "print(in_between(bet_test))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File Parsing\n",
    "\n",
    "Now that we've got the hang of variables, types, and control flow, we can move on to using Python to help us do science!\n",
    "Often scientific software or instruments will give a file of text containing important information, but looking through a long file is tedious.\n",
    "Luckily, Python makes reading through files fast and easy.\n",
    "\n",
    "### Working with file paths - the `os.path` module\n",
    "\n",
    "For this section we'll be working with the file `ethanol.out` which is in the `outfiles` directory.\n",
    "Lets look in the `outfiles` directory.\n",
    "The terminal command `ls`, short for list, returns the contents of a directory.\n",
    "`ls` is not a Python command, but Jupyter Notebooks can run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "butanol.out   ethanol.out   hexanol.out   nonanol.out   pentanol.out\n",
      "decanol.out   heptanol.out  methanol.out  octanol.out   propanol.out\n"
     ]
    }
   ],
   "source": [
    "ls outfiles"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These files are in another directory, which means we need to reference their path.\n",
    "The path tells the computer where to find a file.\n",
    "There are two types of paths, relative and absolute.\n",
    "Relative paths are the path to a file from the present working directory.\n",
    "The present working directory is given by the command `pwd`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/alia/Documents/lab_python_tutorial/PythonTutorial'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pwd"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another thing to note is that Windows paths use `\\` and macOS and Linux paths use `/`.\n",
    "A way to get around this is by using the `os.path` module to ensure that the code runs on all systems.\n",
    "\n",
    "To get the path for `ethanol.out` we would use the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "outfiles/ethanol.out\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "ethanol_file = os.path.join('outfiles', 'ethanol.out')\n",
    "print(ethanol_file)"
   ]
  }
 ],
 "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.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "254a929a8df0d09e1204fbf3643ee75d21f4deeca16e9665512a09f05f306737"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}