Module-03-interactive.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#From-strings-to-lists-to-strings-to-lists\" data-toc-modified-id=\"From-strings-to-lists-to-strings-to-lists-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>From strings to lists to strings to lists</a></span></li><li><span><a href=\"#If-and-else-if-branching-in-code\" data-toc-modified-id=\"If-and-else-if-branching-in-code-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>If and else if branching in code</a></span></li><li><span><a href=\"#Reading-from-a-file\" data-toc-modified-id=\"Reading-from-a-file-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Reading from a file</a></span></li><li><span><a href=\"#Creating-errors,-checking-for-errors-and-handling-errors\" data-toc-modified-id=\"Creating-errors,-checking-for-errors-and-handling-errors-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Creating errors, checking for errors and handling errors</a></span></li><li><span><a href=\"#Challenges\" data-toc-modified-id=\"Challenges-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Challenges</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> All content here is under a Creative Commons Attribution [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) and all source code is released under a [BSD-2 clause license](https://en.wikipedia.org/wiki/BSD_licenses).\n",
    ">\n",
    ">Please reuse, remix, revise, and [reshare this content](https://github.com/kgdunn/python-basic-notebooks) in any way, keeping this notice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 3: Overview\n",
    "\n",
    "We cover the following topics here:\n",
    "\n",
    "1. Reviewing lists and strings, and interchanging between the two.\n",
    "2. If-else branching in your code\n",
    "3. Files: reading from a file; looping over their contents line by line.\n",
    "4. Error creation, error checking and dealing with errors.\n",
    "\n",
    "On the side we will cover some aspects of debugging.\n",
    "\n",
    "## Preparing for this module\n",
    "\n",
    "* Review the sections from last week again, to fill in the blanks in your knowledg: [Strings and Lists](https://runestone.academy/runestone/static/fopp/Sequences/toctree.html), then [for loops](https://runestone.academy/runestone/static/fopp/Iteration/toctree.html), then about [files](https://runestone.academy/runestone/static/fopp/Files/toctree.html)  - up to section 10.5\n",
    "* New: Check your knowledge of if-else branches: https://www.w3schools.com/python/python_conditions.asp\n",
    "\n",
    "Also recommended: \n",
    "* Get a Bitbucket or Github account set up \n",
    "* Get the Git software client installed and running \n",
    "\n",
    "\n",
    "## First, a quick warm-up, with 10 questions:\n",
    "\n",
    "1. How many characters will be returned? ``\"my_string\"[0:5]``\n",
    "2. And here? ``\"my_string \"[5:100:2]``\n",
    "3. What method can you apply to strings to strip away any whitespace, like in the above string?\n",
    "4. What method can you apply to strings to check if the contents of the string are all numbers?\n",
    "5. What function do you use to determine the length of string?\n",
    "6. And the length of a list?\n",
    "7. You want to get, and then remove, the 4th value of the list. How do you do that?\n",
    "8. What happens when you have 2 lists and you write this command: ``list_A + list_B``?\n",
    "9. What is the value of ``output`` after this command: ``output = my_list.reverse()``?\n",
    "10. Tell your colleague how you would write a for loop to print the values in this list, but from back to front: ``[9, 7, 5, 3, 2]``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## From strings to lists to strings to lists\n",
    "\n",
    "In the [prior module](https://yint.org/pybasic02) we focused on lists and strings separately. We also saw they have a lot in common, in terms of behaviour. But there was one key difference: lists are *mutable*, and strings are *immutable* (unchangable).\n",
    "\n",
    "Some things are just more intuitive with lists. For example, if we have:\n",
    "\n",
    "```python\n",
    "my_string = 'A long  sentence, with text    and faulty spacing.'``\n",
    "```\n",
    "\n",
    "How many words are in that sentence? It is easier if you can convert it to a list. \n",
    "\n",
    "**String to list**\n",
    "```python\n",
    "my_string = 'A long  sentence, with text    and faulty spacing.'``\n",
    "string_as_list = my_string.split(' ')\n",
    "print('There are {} words in the string.'.format(len(string_as_list)))\n",
    "```\n",
    "\n",
    "The ``.split(...)`` method is extremely useful, but we did not cover it last time. You can split on any character, or characters. Try it:\n",
    "* ``my_string.split() # mmmmm, what does this do?``\n",
    "* ``my_string.split('e')``\n",
    "* ``my_string.split('en')``\n",
    "\n",
    "\n",
    "**List back to a string**\n",
    "\n",
    "Well to recombine a split string, you can use the ``''.join()`` method. Notice that I wrote it as ``''.join()``, indicating it is a method for string types.\n",
    "\n",
    "Try these lines of code one-by-one, and ensure you can figure out what the ``join`` method does.\n",
    "\n",
    "```python\n",
    "my_list = ['Divided', 'we', 'fall,', 'but', 'united', 'we', 'stand.']\n",
    "print(''.join(my_list))\n",
    "print(' '.join(my_list))\n",
    "print('\\n'.join(my_list))\n",
    "print('\\t'.join(my_list))\n",
    "print(')('.join(my_list))\n",
    "```\n",
    "Which one of the above are you most likely to use the most?\n",
    "\n",
    "**Pro tip**: if you are generating an automated report, you can build up your report paragraph by paragraph:\n",
    "\n",
    "```python\n",
    "report = []\n",
    "report.extend(...) # add a new section\n",
    "report.extend(...) # add the next section\n",
    "...\n",
    "\n",
    "# Convert the whole report to a (long) string\n",
    "print('\\n'.join(report)) \n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If and else if branching in code\n",
    "\n",
    "Like in other languages, Python also has the ability to create branches in the code. \n",
    "\n",
    "> if \\_\\_&lt;condition> \\_\\_ then \\_\\_&lt;action\\>\\_\\_\n",
    "\n",
    "They can also have an ``else`` part:\n",
    "\n",
    "> if \\_\\_&lt;condition> \\_\\_ then \\_\\_&lt;action\\>\\_\\_ else \\_\\_&lt;some other action\\>\\_\\_\n",
    "\n",
    "Or even multiple ``if else`` checks. These are the equivalent of the ``switch`` or ``case`` constructions found in other languages.\n",
    "\n",
    "Indentation is important, as shown in this example.\n",
    "```python\n",
    "slope = ... # some code goes here to calculate the slope\n",
    "if slope > 0:\n",
    "    sign_of_slope = 'positive'\n",
    "elif slope < 0:\n",
    "    sign_of_slope = 'negative'\n",
    "else:\n",
    "    sign_of_slope = 'zero'\n",
    "    \n",
    "print('The slope was observed to be {}.'.format(sign_of_slope))\n",
    "```\n",
    "\n",
    "**Note:** you can have zero or multiple ``elif`` sections in this if-else ladder. The ``else`` part, if required, must go at the end of the ladder.\n",
    "\n",
    "Use the above code to create a prototype for a robotic system which will automatically titrate a solution to a neutral pH, depending on the value of variable ``pH``. Print the appropriate string, depending on the condition:\n",
    "\n",
    "* If $0 \\leq \\text{pH} \\leq 5.5$: \"The solution is acidic. Adding 2 mL of ammonia hydroxide, NH4OH.\"\n",
    "* If $5.5 \\lt \\text{pH} \\leq 8.5$: \"The solution is neutral. Adding nothing.\"\n",
    "* If $8.5 \\lt \\text{pH} \\leq 14$: \"The solution is basic. Adding 1.5 mL of phosphoric acid, H3PO4.\"\n",
    "* If $\\text{pH} < 0$ or $\\text{pH} > 14$: \"The pH value is out of range. Check your pH probe.\"\n",
    "\n",
    "Run your code for some/all of these values of pH values to ensure all branches in your code are working as you expected: ``-4.2, 0, 3.721, 5.5, 5.500001, 8.5, 10.98765, 14, 140``\n",
    "\n",
    "This is called code testing. In the ***Advanced section*** of the course we will come back to formal methods of code testing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the [prior module](https://yint.org/pybasic01) we were writing code to automatically write a report for us. The code generated this output:\n",
    "\n",
    "> The regression trend of **45.9** mg/day was detected for this product, with a p-value of **0.00341**. This indicates that there is a **rising** trend over time.\n",
    "\n",
    "Again, use the above code as starting point, but add to it. At the end, the code should be able to produce all 4 variants of the outputs shown below, depending on the value of ``slope`` and ``p_value``.\n",
    "* The ``slope`` is either considered to be **rising** or **falling**.\n",
    "* A ``p_value`` greater than 0.20 requires that an extra phrase be added.\n",
    "\n",
    "*Variant 1*: The regression trend of **12.4** mg/day was detected for this product, with a p-value of **0.0141**. This indicates that there is a **rising** trend over time, which indicates an important influence.\n",
    "\n",
    "*Variant 2*: The regression trend of **12.4** mg/day was detected for this product, with a p-value of **0.425**. This indicates that there is a **rising** trend over time, but it likely has no impact on the system.\n",
    "\n",
    "*Variant 3*: The regression trend of **-5.2** mg/day was detected for this product, with a p-value of **0.142**. This indicates that there is a **falling** trend over time, which indicates an important influence.\n",
    "\n",
    "*Variant 4*: The regression trend of **-5.2** mg/day was detected for this product, with a p-value of **0.209**. This indicates that there is a **falling** trend over time, but it likely has no impact on the system.\n",
    "\n",
    "Check that your code correctly produces the output when:\n",
    "* ``slope = 0.00542`` and ``p_value = 0.0419``\n",
    "* ``slope = -521`` and ``p_value = 0.2000001``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading from a file\n",
    "\n",
    "We will cover simple reading from a text file here. The general, simple way to read a file containing any regular text is:\n",
    "\n",
    "```python\n",
    "filename = \"myfile.txt\"\n",
    "f = open(filename, \"r\")\n",
    "all_lines_as_string = f.read()\n",
    "print(type(all_lines_as_string))\n",
    "\n",
    "# Do something with the list ``all_lines``. One entry per line.\n",
    "\n",
    "# Close the file afterwards:\n",
    "f.close()\n",
    "```\n",
    "\n",
    "**Try these steps**:\n",
    "1. Go to the same directory as where your Python script is being saved.\n",
    "2. Create a new text file, called ``myfile.txt``, and write more than one line of text to your file.\n",
    "3. Save your text file.\n",
    "4. Run the above code, modifying it so that it will:\n",
    "\n",
    "   * Print all the text in your file, ``all_lines_as_string``, in uppercase.\n",
    "   * What is the length of ``all_lines_as_string``?\n",
    "5. Change the above code so that the second line contains: ``all_lines_as_list = f.readlines()``\n",
    "\n",
    "    * Verify that ``all_lines_as_list`` is indeed a list.\n",
    "    * Write a for-loop that prints the length of each line:\n",
    "\n",
    "        ``Line 1 has __ characters``\n",
    "        \n",
    "        ``Line 2 has __ characters``\n",
    "        etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above is a good start with files, but there are some shortcomings which we can improve on:\n",
    "\n",
    "* You must have the file called ``myfile.txt`` in the same directory as where you are running Python.\n",
    "* You must not forget to close the file again.\n",
    "\n",
    "\n",
    "1. Move the file ``myfile.txt`` to a different directory on your computer.\n",
    "2. Use the following construction to create the ``full_filename`` variable :\n",
    "\n",
    "```python\n",
    "base_folder_mac_or_linux = '/users/home/yourname'\n",
    "base_folder_windows = r'C:\\Users\\home\\yourname'  # do you remember why we use the r'...' string?\n",
    "filename = 'myfile.txt'\n",
    "import os\n",
    "full_filename = os.path.join(base_folder_windows, filename)\n",
    "f = open(full_filename, \"r\")\n",
    "# Do something with variable ``f``\n",
    "f.close()\n",
    "```\n",
    "3. Modify the code you wrote in the prior question to use this new structure. Choose either the ``base_folder_mac_or_linux`` or ``base_folder_windows`` variable and modify it, based on the type of computer you are working on.\n",
    "4. Verify that ``full_filename`` is indeed what you expect it to be: the full path name to your text file.\n",
    "\n",
    "\n",
    "We still have not solved the last shortcoming, regarding closing the file. Read this Stackoverflow page [on why you should close files](https://stackoverflow.com/questions/25070854/why-should-i-close-files-in-python). Python can automatically close the file for you, if you use this structure shown below. Notice the code is essentially the same, expect you replace one line, and remove the ``f.close()`` statement.\n",
    "\n",
    "```python\n",
    "# This is the preferred way to open and use files in Python\n",
    "\n",
    "base_folder_mac_or_linux = '/users/home/yourname'\n",
    "base_folder_windows = r'C:\\Users\\home\\yourname'  # why the r'...' string?\n",
    "filename = 'myfile.txt'\n",
    "import os\n",
    "full_filename = os.path.join(base_folder_windows, filename)\n",
    "with open(full_filename, \"r\") as f:\n",
    "    # Do something with variable ``f``, for example:\n",
    "    file_contents = f.readlines()\n",
    "    # What \"type\" is ``file_contents``?\n",
    "    # Other statements go in the with block, if required.\n",
    "   \n",
    "# The file will be closed at this point, when the ``with`` \n",
    "# block is exited.\n",
    "```\n",
    "\n",
    "Copy and paste your file handling code above, and modify it to use the ``with`` block instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating errors, checking for errors and handling errors\n",
    "\n",
    "Sometimes in our code we want to check if a variable has a certain value, or a certain condition, before we continue with the rest of the code.\n",
    "\n",
    "1. Try this: ``print(4/0)`` and you will get a ``ZeroDivisionError``. We say that Python has **thrown** an error.\n",
    "\n",
    "2. Try throwing another error:\n",
    "```python\n",
    "import math\n",
    "pH = -0.024\n",
    "log_pH = math.log(pH)\n",
    "```\n",
    "and you will get an error, specifically an error of the type called ``ValueError``.\n",
    "\n",
    "3. Lastly, try this ``[1, 2, 3].pop(4)`` will throw which type of error? Does it make sense that that error is thrown?\n",
    "\n",
    "There are several ways to deal with these errors. The crudest is to simply stop the program if a condition is not met.\n",
    "\n",
    "```python\n",
    "pH = 2.87\n",
    "assert(pH > 0)\n",
    "\n",
    "pH = -0.024\n",
    "assert(pH > 0)\n",
    "```\n",
    "\n",
    "What difference do you see in the output between the two ``assert(...)`` statements?\n",
    "\n",
    "A more sophisticated way to deal with this is to create an ``if-else`` branch in your code. In the above examples you can:\n",
    "\n",
    " 1. check the value of the denominator before you do the division;\n",
    " 2. check if pH values are above and below zero;\n",
    " 3. check if the length of your list is long enough before you do ``.pop(4)``.\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Writing an if-else for every anticipated situation [can be messy, and lead to slower code](https://stackoverflow.com/questions/7604636/better-to-try-something-and-catch-the-exception-or-test-if-its-possible-first).\n",
    "\n",
    "A cleaner way to deal with this is with a try-except structure. You **try** to run the instructions, and should an **except**ion occur, then you *catch* the error that was *thrown* by the software.\n",
    "\n",
    "```python\n",
    "import math\n",
    "\n",
    "try:\n",
    "    # Some code goes here that calculates or gets the pH value\n",
    "    pH = -0.024\n",
    "    log_pH = math.log(pH)\n",
    "    print('The logged pH is {}'.format(log_pH))\n",
    "except ValueError as error:\n",
    "    print('Cannot calculate a negative log.')\n",
    "    print('Python returned this error: {}'.format(error))   \n",
    "```\n",
    "\n",
    "All the code in the **try** block will be executed and completed if no exceptions occur. The code in the **except** block will only run if the exception is triggered.\n",
    "\n",
    "**Try it yourself** \n",
    "\n",
    "Try writing a try-except block for the situation where you calculate the roots of the quadratic equation: $ax^2 + bx + c = 0$. In other words, what are the values of $x$ that set the equation equal to zero. We saw this in a [prior session](https://yint.org/pybasic01).\n",
    "\n",
    "$$x={\\frac {-b\\pm {\\sqrt {b^{2}-4ac\\ }}}{2a}}$$\n",
    "\n",
    "Write the code, using a try-except structure, to calculate the value of $x$ for these 2 situations:\n",
    "* a=3, b=6, c=3  `` # this will go through the 'try' block``\n",
    "* a=0, b=1, c=2   ``# this will go through the 'except' block``\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Another try-except* exercise, but this time for files. \n",
    "\n",
    "```python\n",
    "try:\n",
    "    with open('non-existent-file.txt') as file:\n",
    "        read_data = file.read()\n",
    "except FileNotFoundError as error_nofile:\n",
    "    print(\"Could not open file: {}.format(error_nofile))\n",
    "```\n",
    "\n",
    "Using try-except structures in your code makes your code robust.\n",
    "\n",
    "For later, read this page, https://realpython.com/python-exceptions/, which nicely shows how to extend your knowledge, and use ``try-except-else-finally`` structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenges\n",
    "\n",
    "Next you should proceed to do either Challenge 1, or Challenge 2 (***or both!***). \n",
    "\n",
    "After that you should complete Challenge 3. Challenge 4 is a variation of Challenge 3, which you can easily complete as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 1\n",
    "\n",
    "Several websites provide random DNA sequences that you can use in your code. We would like to calculate various statistics on the DNA string, e.g. ``dna_string = 'CGAGATCAGATACGATTCTTATATTCTCAATGAGGAGCCAT'``.\n",
    "* The number of C, G, T and A bases.\n",
    "* The percentage of C, G, T and A bases. Does this look right?\n",
    "* The number of (G and C) bases divided by the total base length.\n",
    "* The number of (A and T) bases divided by the total length.\n",
    "* The ratio of A/T and the ratio G/C.\n",
    "\n",
    "\n",
    "1. It is always a good tip to develop your code on some input that you already know the answer to. So we will create a string of 4000 entries, with approximately 1000 C, G, T and A bases in the string. Then we know the above 5 statistics should approximately be: \n",
    "\n",
    "    * [1000, 1000, 1000, 1000]\n",
    "    * [25, 25, 25, 25]\n",
    "    * 2000/4000\n",
    "    * 2000/4000\n",
    "    * 1000/1000 and 1000/1000\n",
    "\n",
    "    To create our \"known input\" we will use the ``numpy`` library in Python. We will see this library later on, but for now you can just use this code as-is:\n",
    "\n",
    "    ```python\n",
    "    import numpy as np \n",
    "    bases = ['C', 'G', 'T', 'A']\n",
    "    length = 4000\n",
    "\n",
    "    # Uniformly select letters from the above list (creates a balanced sample)\n",
    "    dna_list = np.random.choice(bases, length).tolist()\n",
    "    dna_string = ''.join(dna_list)   # see how useful the .join() function is?\n",
    "\n",
    "    # Next, write the code here to calculate the statistics on this DNA sequence\n",
    "```\n",
    "\n",
    "2. Generate a string of 10000 DNA bases from the internet (https://www.bioinformatics.org/sms2/random_dna.html) and copy/paste them directly to a file on your computer. \n",
    "\n",
    "    Open that file, using the file reading code above, to calculate various statistics on this string. Do not hard-code any variables into your code: your code should be reusable for any length string.\n",
    "    \n",
    "    Do the statistics from the Bioinformatics site seem to come from a uniform distribution (25% chance for C, G, A or T), or do the distribution of the base pairs follow the distribution [discovered by Chargaff](https://en.wikipedia.org/wiki/Chargaff%27s_rules#Percentages_of_bases_in_DNA)? If so, which organism do they approximate?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 2\n",
    "\n",
    "This challenge is to read in a constant stream of values and calculate the moving average of them. This is, again, based, on a real case that happens rather frequently.\n",
    "\n",
    "The [concentration of ammonia](http://openmv.net/info/ammonia) values can be downloaded and saved to your computer. Using the [code shown above](#Reading-from-a-file), create a ``with`` block, and read the values from the file line-by-line:\n",
    "\n",
    "You should check that what you get here in Python matches what you see in Excel, or some other software that can open the CSV file for you.\n",
    "\n",
    "```python\n",
    "# Read the file directly from your local computer\n",
    "filename = 'ammonia.csv'\n",
    "with open(filename) as f:\n",
    "    for index, concentration in enumerate(f.readlines()):\n",
    "        \n",
    "        # Skip the first line of the file: it is a text heading.\n",
    "        if index == 0:\n",
    "            continue\n",
    "            \n",
    "        # Convert the text to a float, and then do something with it ...\n",
    "        print(float(concentration))\n",
    "```\n",
    "\n",
    "*Building up the problem*: \n",
    "1. Calculate the cumulative sum of the values in the CSV file.\n",
    "2. Now modify your code and at the end divide by the total number of samples you added up, so you report the global average of all values in the file.\n",
    "3. Next, solve the challenge: the idea is to calculate the moving average over $n=5$ values; called a window of 5 values. Accumulate the first 5 entries in the window and calculate the average. Print the average to the screen. Then throw away the first entry, add the 6th entry to update your window. Calculate the average based on the 2nd to the 6th value. Keep going until you run out of values. \n",
    "\n",
    " As solution: the first moving average value is 36.92, then the next one is 38.476, etc.\n",
    "\n",
    " Modify your code only in 1 place to repeat the calculations, but with a window size of $n=15$ steps. In other words, your window size should not be *hard-coded* into your Python code.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 3\n",
    "\n",
    "This challenge is to create a very crude integrator for an ordinary differential equation. Based on Newton's law of cooling, placing an object, like a bottle of water in a cold environment, like a fridge, the temperature of the water, $T$, changing over time $t$, can be modeled as:\n",
    "$$ \\dfrac{dT}{dt} = -k (T-F)$$\n",
    "\n",
    "The fridge has a constant temperature, $F=5$°C; for this system, the value of $k = 0.08$. The equation can be rewritten as: $$ \\dfrac{\\Delta T}{\\delta t} = -k (T - F)$$ for a short change in time, $\\delta t = 2$ minutes.\n",
    "$$T_{i+1} - T_i = -k (\\delta t)(T_i - F)$$ \n",
    "\n",
    "which shows how the temperature at time point $i+1$ (one step in the future) is related to the temperature now, at time $i$. \n",
    "\n",
    "You can rewrite the equation as: $$ T_{i+1} = T_i -k (\\delta t)(T_i - F)$$\n",
    "\n",
    "In a loop, show how the temperature changes over time, starting from the temperature $T_{i=0} = 25$°C. Your output should look something like this:\n",
    "\n",
    "> At time 0 minutes the temperature is 25.0\n",
    "> \n",
    "> At time 2 minutes the temperature is 21.8\n",
    "\n",
    "1. How long does it take for your water to reach the temperature of the fridge?\n",
    "2. What happens if you use a different $\\delta t$ value during the integration? Try a really small value, or a larger value.\n",
    "3. For a more \"powerful\" fridge which cools quicker: do you need a bigger or smaller value of $k$?\n",
    "4. How long will it take a cup of water which has just boiled to cool down?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like in the previous challenge we want to integrate an equation, but this time for bacteria growing on a plate.\n",
    "\n",
    "The equation for growth is\n",
    "\n",
    "$$ \\dfrac{dP}{dt} = rP $$\n",
    "\n",
    "where $P$ is the number of bacteria in the population, and $r$ is their rate of growth [number of bacteria/minute]. Integrating this equation will show exponential growth. This is not realistic. Eventually the bacteria will run out of space and their food source. So the equation is modified:\n",
    "\n",
    "$$ \\dfrac{dP}{dt} = rP - aP^2$$\n",
    "where they are limited by the factor $a$ in the equation.\n",
    "\n",
    "The differential equation can be re-written as: \n",
    "$$P_{i+1} - P_i = \\left[\\,rP_i  -a\\,P_i^2\\,\\right]\\delta t$$ \n",
    "\n",
    "\n",
    "which shows how the population at time point $i+1$ (one step in the future) is related to the population size now, at time $i$ over a short interval of time $\\delta t$ minutes.  You can read more about these <a href = \"https://math.libretexts.org/Bookshelves/Calculus/Book%3A_Calculus_(OpenStax)/8%3A_Introduction_to_Differential_Equations/8.4%3A_The_Logistic_Equation\">logistic equation models</a>.\n",
    "\n",
    "In a loop, show how the population changes over time, starting from an initial population of $P_{i=0} = 500$ bacteria. The growth rate for this culture is $r=0.032$ and the coefficient $a = 1.4 \\times 10^{-7}$.\n",
    "\n",
    "\n",
    "Your printed output should look something like this:\n",
    "\n",
    "> At time 10 minutes there are 660 bacteria\n",
    ">\n",
    "> At time 20 minutes there are ___ bacteria\n",
    "\n",
    "Try integrating over \n",
    "\n",
    "* different durations of time\n",
    "* using different step sizes of $\\delta t$\n",
    "* Do you get a steady population size?\n",
    "* Is that ultimate population size dependent on the number of bacteria you start with?\n",
    "\n",
    "Later on in the course we will see how to collect these follow and plot them. But looking at the number, what shape does the curve have? Is it what you expect?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To cover during the interactive session:\n",
    "\n",
    "* Debugging in Spyder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!-- Credit to the BSD licensed code from:\n",
       "https://github.com/engineersCode/EngComp1_offtheground/blob/master/style/custom.css\n",
       "-->\n",
       "\n",
       "<link href=\"https://fonts.googleapis.com/css?family=Merriweather:300,300i,400,400i,700,700i,900,900i\" rel='stylesheet' >\n",
       "<link href=\"https://fonts.googleapis.com/css?family=Source+Sans+Pro:300,300i,400,400i,700,700i\" rel='stylesheet' >\n",
       "<link href='https://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' >\n",
       "<style>\n",
       "\n",
       "@font-face {\n",
       "    font-family: \"Computer Modern\";\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "}\n",
       "\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: rgb(245,245,245);\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "#notebook li { /* More space between bullet points */\n",
       "margin-top:0.5em;\n",
       "}\n",
       "\n",
       "/* draw border around running cells */\n",
       "div.cell.border-box-sizing.code_cell.running {\n",
       "    border: 1px solid #111;\n",
       "}\n",
       "\n",
       "/* Put a solid color box around each cell and its output, visually linking them*/\n",
       "div.cell.code_cell {\n",
       "    background-color: rgb(256,256,256);\n",
       "    border-radius: 0px;\n",
       "    padding: 0.5em;\n",
       "    margin-left:1em;\n",
       "    margin-top: 1em;\n",
       "}\n",
       "\n",
       "\n",
       "div.text_cell_render{\n",
       "    font-family: 'Source Sans Pro', sans-serif;\n",
       "    line-height: 140%;\n",
       "    font-size: 110%;\n",
       "\n",
       "/*   margin-left:auto;*/\n",
       "/*    margin-right:auto;*/\n",
       "}\n",
       "\n",
       ".table tr {\n",
       "    text-align:left;\n",
       "}\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Merriweather', serif;\n",
       "    font-style:regular;\n",
       "    font-weight: bold;\n",
       "    font-size: 250%;\n",
       "    line-height: 100%;\n",
       "    color: #004065;\n",
       "    margin-bottom: 1em;\n",
       "    margin-top: 0.5em;\n",
       "    display: block;\n",
       "}\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Merriweather', serif;\n",
       "    font-weight: bold;\n",
       "    font-size: 180%;\n",
       "    line-height: 100%;\n",
       "    color: #0096d6;\n",
       "    margin-bottom: 0.5em;\n",
       "    margin-top: 0.5em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Merriweather', serif;\n",
       "\tfont-size: 150%;\n",
       "    margin-top:12px;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: regular;\n",
       "    color: #008367;\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {    /*Use this for Challenge Problems*/\n",
       "    font-family: 'Merriweather', serif;\n",
       "    font-weight: bold;\n",
       "    font-size: 150%;\n",
       "    line-height: 120%;\n",
       "    text-align: left;\n",
       "    margin-top: 12px;\n",
       "    margin-bottom: 5px;\n",
       "    margin-left: 0pt;\n",
       "    font-style: regular;\n",
       "    color: #8B008B;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {  /*Use this for small titles*/\n",
       "    font-family: 'Source Sans Pro', sans-serif;\n",
       "    font-weight: regular;\n",
       "    font-size: 130%;\n",
       "    color: #e31937;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .5em;\n",
       "    margin-top: 1em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 { /*use this for copyright note*/\n",
       "    font-family: 'Source Code Pro', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 9pt;\n",
       "    line-height: 100%;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       "    .CodeMirror{\n",
       "            font-family: \"Source Code Pro\";\n",
       "\t\t\tfont-size: 90%;\n",
       "    }\n",
       "/*    .prompt{\n",
       "        display: None;\n",
       "    }*/\n",
       "\n",
       "\n",
       "    .warning{\n",
       "        color: rgb( 240, 20, 20 )\n",
       "        }\n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"],\n",
       "                           equationNumbers: { autoNumber: \"AMS\", useLabelIds: true}\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# IGNORE this. Execute this cell to load the notebook's style sheet.\n",
    "from IPython.core.display import HTML\n",
    "css_file = './images/style.css'\n",
    "HTML(open(css_file, \"r\").read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "376px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}