Workshop2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CHY1610: Introduction to Scientific Computing for Chemists\n",
    "## Dr Daniel Cole\n",
    "* Room: BEDB.2.29\n",
    "* email: daniel.cole@ncl.ac.uk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FAQs\n",
    "\n",
    "Before we start this week's workshop, here are the responses to a couple of Frequently Asked Questions from last week:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q: How do I write e.g. 5 x 10$^{-3}$ in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are a few options actually:\n",
    "\n",
    "a = 0.005  # long hand, not recommended for smaller numbers\n",
    "b = 5.0 * 10**-3 # using exponent notation, not recommended\n",
    "c = 5e-3 # scientific notation, recommended\n",
    "\n",
    "# All should give the same output:\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q: How do I calculate the negative of log(x)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remember that we have access to lots of functions through the math library:\n",
    "import math\n",
    "\n",
    "# The following expression is used to call the function (log) \n",
    "# from the math library.\n",
    "x = 5\n",
    "print(math.log10(x))\n",
    "\n",
    "# math.log10(x) can be treated as a single object or number\n",
    "# So to find the negative, we can simply put a minus sign in front:\n",
    "print(-math.log10(x))\n",
    "\n",
    "# Or you could assign the output of the log function to a variable:\n",
    "a = math.log10(x)\n",
    "print(-1.0 * a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feel free to send me questions to answer in next week's workshop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Workshop 2: Strings, lists & for loops.\n",
    "\n",
    "Last time, we started to use python and the Jupyter notebook to perform and print the results of some basic mathematical expressions, and to assign variables and use comparison and logic operators. This time we'll be looking in more detail at the *string* data type and producing more sophisticated code.\n",
    "\n",
    "### Strings\n",
    "\n",
    "A Python string object is a sequence of characters, which is enclosed in single or double quotes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string1 = \"cat\"\n",
    "string2 = 'dog'\n",
    "print(string1, string2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we saw last time, we can output more than one string from the `print()` command by separating the inputs by a comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string3 = 'We choose to go to the moon. We choose to go to '\\\n",
    "            'the moon in this decade and do the other things, not '\\\n",
    "            'because they are easy, but because they are hard...'\n",
    "print(string3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we can see that there are no limits on the length of a string, but to make it easier to read we make use of the `\\` character to break it up over several lines. When we print the string, however, the line breaks do not appear. If instead we wish the string to be printed as written, then we can use triple quotes`\"\"\" \"\"\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string4 = \"\"\"We choose to go to the moon. We choose to go to \n",
    "the moon in this decade and do the other things, not \n",
    "because they are easy, but because they are hard...\n",
    "\"\"\"\n",
    "print(string4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yet another option is to use the `\\n` character. We saw above the backslash `\\` being used as a line break. When used inside a string it signifies a character with a special meaning (*a string literal*). In this case, `\\n` means 'start a new line'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string5 = 'We choose to go to the moon. We choose to go to \\n'\\\n",
    "            'the moon in this decade and do the other things, not \\n'\\\n",
    "            'because they are easy, but because they are hard...'\n",
    "print(string5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might also find the sequence `\\t` useful for inserting a tab:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_tab = \"cat\\tdog\"\n",
    "print(string_tab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also extend the range of characters open to us by using [Unicode](http://www.unicode.org/charts/):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "angstrom='3 \\u212B'\n",
    "print(angstrom)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 1.** (Remember to copy your answers into the answersheet-CHY1610 notebook.) In the cell below, insert a string, which when printed gives the following output:\n",
    "\n",
    "```The Bohr radius is equal to:\n",
    "0.529 Å```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mystring1 = \"\"\n",
    "print(mystring1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.** In the cell below, insert a string, which when printed gives the following output:\n",
    "```\n",
    "1.\tA mixture of Zn, HgCl2, H2O, and conc. HCl was stirred for 20 min. \n",
    "2.\tThe aqueous layer was decanted and rinsed with water.```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mystring2 = \"\"\"\n",
    "\"\"\"\n",
    "print(mystring2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As well as printing strings (see above), we can use *indexing* (return a single character) and *slicing* (produce a substring) to manipulate strings. (Note that the first character is labelled by 0). Taking the example from above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string3 = 'We choose to go to the moon. We choose to go to '\\\n",
    "            'the moon in this decade and do the other things, not '\\\n",
    "            'because they are easy, but because they are hard...'\n",
    "\n",
    "#Index the first character of the string\n",
    "print(string3[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Slice all characters between indices 3 and 8 (note that 9 is not included)\n",
    "print(string3[3:9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The full options for slice are `string3[start:stop:step]`. We have already demonstrated the use of start and stop. Step can be used to skip a defined number of characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Slice all characters between indices 3 and 8 (note that 9 is not included)\n",
    "#Skip every 2nd character\n",
    "print(string3[3:9:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the defaults for start and stop are the first and last character, respectively, and remember that the stop character is not included in the output. The default step size is 1. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Print every 10th character in string3\n",
    "print(string3[::10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 3.** Slice the following string to produce the output `MTWTFSS`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "daysofweek = 'Mon, Tue, Wed, Thu, Fri, Sat, Sun'\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if you choose an index outside the allowed range (e.g. `print(string3[200])`)? Python fails with an error. In this case the error is quite descriptive and if this happens should allow you to go back to fix the problem. We can also search within a string using the `in` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'choose' in string3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'elephant' in string3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above cells evaluate to True and False, respectively, because the word `'choose'` is found in `string3`, but `'elephant'` is not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many tools available for manipulating strings, which can make Python a very useful language for editing e.g. datafiles. Here are some examples (I certainly do not recommend learning commands like these, but it is useful to know they exist and if you use them enough they will stick in your brain):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(string3) # print the length of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# append to the string (see augmented assignment from week 1):\n",
    "string3 += ' (John F. Kennedy)' \n",
    "print(string3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string3.upper() # print in upper case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string3.title() # print in title case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string3.replace('...','; because that goal will...') # replace (old, new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string3.replace('...','; because that goal will...').upper() # chain two commands together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string3.count(\" \") # count the number of spaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "string3.split(\" \") # splits string using white space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above commands are accessed using the dot notation, which we saw last time in the context of the `math` module. There is almost certainly a command for doing anything you might like, again searching online is a good start if it's not covered above. See also chapter 2.3.7 (Hill) for more information on string formatting if interested.\n",
    "\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": {},
   "source": [
    "### Formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While you should certainly know the basics of string formatting, as scientists, we are more likely to be interested in python for its mathematical capabilities, so let's return to some numeric data types.\n",
    "\n",
    "Hopefully, you're not happy with the number of significant figures that our answers used in some of the problems last time. In the following example, our approximate value of pi is given to 15 decimal places by default:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 22/7\n",
    "print('Pi is approximately', pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can produce the same result using the `format` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 22/7\n",
    "print('Pi is approximately {0}'.format(pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the `{0}` in the printed string is replaced by the *argument* given to `format()` (in this case the variable `pi`). The advantage to this is that we can now change the formatting instructions used to print `pi`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Pi is approximately {0:4.2f}'.format(pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have requested pi to be printed as a *floating point number* given to two decimal places with a total length of four characters. Try experimenting with the format instructions in `{0:4.2f}` to change the number of decimal places printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We mentioned above the term floating point number. The examples below demonstrate the differences between this notation and scientific notation. They also show that more than one argument can be passed to format, and they are printed in the fields `{0}`, `{1}`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 78.90\n",
    "b = 1.2345e-6\n",
    "print('{0:5.1f} {1:15.8f}'.format(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('{0:5.1e} {1:15.8e}'.format(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('{0:5.1e} {1:15.8e} {2}'.format(a,b,'mystring'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In these more complex examples, we have asked for the first argument `a` to have a total length of 5 characters, and be printed to 1 decimal place. The second argument `b` has a total length of 15 characters, and is printed to 8 decimal places. `f` requests a floating point number, while `e` uses scientific notation. The last example shows how to include a string in the output. Experiment with the above notation. You may wish to fix the formatting of some of the examples from last week."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 4.** A ball of mass 4.4 kg is travelling with speed 2.23 m/s. What is the ball's kinetic energy? Print out your answer to 2 decimal places, including units."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = 4.4 # kg\n",
    "v = 2.23 # m/s\n",
    "ke = 0.5 * m * v**2\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists and tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we will see later in the course, we will often wish to perform the same operations over and over again on large amounts of data. For this reason, it is extremely important to be able to hold and manipulate an ordered list of data. The first example we will meet now is called a *list*. A list can hold different types of data, and can be changed (e.g. added to, re-ordered...)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [1, 'two', 3.14159]\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we saw for strings, we can print items from the list (again remembering to index from 0) and also update them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list1[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1[1] = 2\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As for strings, there are many methods available for manipulating lists, here are some examples and more information may be found [here](https://docs.python.org/3/tutorial/datastructures.html):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1.append(0.5)\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert item 'new' at index 3\n",
    "list1.insert(3,'new')\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1.remove('new')\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1.sort()\n",
    "list1.reverse()\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the last step, we have first sorted the list numerically, then reversed the order.\n",
    "\n",
    "**Example.** Clean up this list of data `3, 6, 3, 45, 87, 234, 22, '##', 78` and output the largest number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2 = [3, 6, 3, 45, 87, 234, 22, '##', 78]\n",
    "list2.remove('##')\n",
    "list2.sort()\n",
    "# pop removes and returns the last item in the list\n",
    "list2.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Allowing lists to be over-written can cause unexpected behaviour in your code. Where this behaviour is not needed, it is better practice to use the `tuple`object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1 = (3.14159, 2, 1, 0.5)\n",
    "tuple1[1] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have created the `tuple` using `()` instead of `[]`, but now attempting to overwrite element 1 results in an error (as it should)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous section, we saw that we can use *lists* or *tuples* to store ordered lists. Now let's look to see how we can take each of the items in those lists, and perform some operation on each in turn. This is demonstrated by an example we saw last week:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scientists = [ 'Isaac Newton', 'Marie Curie', 'Albert Einstein' ]\n",
    "for name in scientists:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the format used. Each of the scientists in turn is assigned to the variable `name` for the block of code that follows the `:` symbol. That is we are iterating through all the items in the list, in this case, printing each item in turn. The `for` loop does not terminate until it reaches the end of the list. The indentation is important (try removing it), and can be inserted using TAB (or four spaces). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use *nested loops*. Try to work out from the output what the following code is doing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list = [ 1, 2, 3 ]\n",
    "for i in list:\n",
    "    for j in list:\n",
    "        print('The result of multiplying {0} by {1} is {2}'.format(i, j, i*j))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is not too much effort to type out the lists above, but what if we want to loop over 100s of data points? A convenient object is the `range`, which has the general format: ```range(a0, n, stride)```. This creates a list of length `n` starting at `a0` (default value is 0) with spacing `stride` (default 1):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,11,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print('{0:6}'.format(i**2), end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the second example, we have made use of the default arguments to `range`, that is, we have incremented from 0 to 9 in steps of 1, and also changed the formatting to remove the new line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example.** In a first-order reaction A &rarr; B, we can write the rate of change of the concentration of A with time as (see your chemical kinetics lectures):\n",
    "\n",
    "$\\frac{d[A]}{dt}$ = -k [A]\n",
    "\n",
    "The initial concentration of A is 1 M and the rate of reaction, k, is 0.1 s$^{-1}$. Use a `for` loop to calcuate the concentration of A after 10 seconds of the reaction. (See the accompanying lecture notes for an explanation of the *numerical modelling* used here)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set initial concentration [A]_0 and rate constant:\n",
    "conc_a = 1.0 # mol/L\n",
    "k = 0.1 # s^-1\n",
    "\n",
    "# discrete time step to use (in seconds):\n",
    "timestep = 0.0001\n",
    "\n",
    "# total time (in seconds):\n",
    "tot_time = 10\n",
    "\n",
    "# iterate over the required number of time steps:\n",
    "for i in range(int(tot_time / timestep)):\n",
    "    change_in_a = -k * conc_a * timestep # change in concentration of [A]\n",
    "    conc_a += change_in_a # update new concentration of [A]\n",
    "\n",
    "# print final answer after loop has terminated:\n",
    "print('Final [A] is {0:6.4f}'.format(conc_a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 5.** Use an *analytical* equation to calculate the expected concentration of A after 10 seconds (see accompanying lecture). Enter your *analytical* expression in the cell below (make sure your answer is printed to 4 d.p.). Does your value agree with the numerical result above? Change the time step in the above example code to `timestep = 1` second. What happens to the numerical result and why? In the above expression for the range `int(tot_time / timestep)`, why is the `int()` function required?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "conc_a_0 = 1.0 # initial concentration, mol/L\n",
    "k = 0.1 # s^-1\n",
    "tot_time = 10 # total time (in seconds)\n",
    "\n",
    "# write an analytical equation for the concentration of A\n",
    "# after 10 seconds and print it out (including formatting):\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(Difficult) Example (for interest only).** Use a `for` loop to calculate $\\pi$ from the first 100 terms of the *Madhava series*:\n",
    "\n",
    "$\\pi$ = $\\sqrt12$ ( 1 - $\\frac{1}{3\\times 3}$ + $\\frac{1}{5\\times 3^2}$ - $\\frac{1}{7\\times 3^3}$ +... )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "# Initialise pi to zero\n",
    "pi = 0.0\n",
    "\n",
    "# Loop over i in the range 0 to 99:\n",
    "for i in range(100):\n",
    "    sign = (-1)**(i) # alternates between +1 and -1\n",
    "    pi += sign / ((1+2*i)*3**(i)) # calculate each term in series from i\n",
    "\n",
    "# Include sqrt(12) prefactor\n",
    "pi *= math.sqrt(12)\n",
    "\n",
    "# Print estimate of pi and the difference relative to the true value:\n",
    "print(pi, math.pi - pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning outcomes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In today's workshop, you have learned how to:\n",
    "* **Print** and manipulate strings, and **format** numbers;\n",
    "* Store data in **lists**;\n",
    "* Use **for loops** to iterate over large amounts of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}