hammingdist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introductory Programming in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This workshop aims to teach some fundamentals of programming, using Python. We won't have time to cover all the concepts involved in programming, but we will give an introduction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this workshop we'll work towards a final goal: write a program in Python to calculate the Hamming distance.\n",
    "\n",
    "To do this we'll need to learn about:\n",
    "\n",
    "- writing functions\n",
    "- using variables\n",
    "- conditionals (if statements)\n",
    "- loops (for statements)\n",
    "- lists\n",
    "- strings\n",
    "\n",
    "If you can do this, you'll have learnt lots of important programming concepts, and implemented our first bioinformatics algorithm!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note: This workshop has been written for Python 3. If you are using Python 2, you should be able to make everything work by first running the Python command:*\n",
    "\n",
    "    from __future__ import print_function, division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hamming distance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Hamming distance between two strings is the number of positions at which they have different characters.\n",
    "\n",
    "For instance, compare these strings:\n",
    "\n",
    "    GATTACA\n",
    "    GACTATA\n",
    "\n",
    "They are different at two locations:\n",
    "\n",
    "    GATTACA\n",
    "      |  |\n",
    "    GACTATA\n",
    "\n",
    "So the Hamming distance is 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hamming distance is the simplest edit distance metric that we will look at for string alignment. It tells us the edit distance between two strings if we're only allowed to make substitutions - no insertions or deletions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The concept of Hamming distance applies to any kind of string, not just DNA sequences. As an exercise, work out (on paper) the Hamming distance between `QUANTUM` and `QUENTIN`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Short words are easy to do on paper, or in your head. Can you find the Hamming distance between:\n",
    "\n",
    "    ACTGTGCAATACCTAAGTGAAAGGGGTGCATAGATCATTCTTTCGTTACCTCGGGTGCTATGAAGTGGACCATCATTGAGAC\n",
    "    ACTCCTCTGTGTCTAAGTGAAAGGGGTGCTTGCAGGGTAATCCTTCCACCTGATACCGACTCGGGTGGACCATCATTGACGG\n",
    "\n",
    "This is pretty painful to do by hand. For real analysis you might need to compare strings hundreds or thousands of letters long, and do it again and again.\n",
    "\n",
    "But this is exactly what computers are for. Once we've written a program to calculate Hamming distance, we'll be able to compare lots of long strings easily. \n",
    "\n",
    "Our final goal for the workshop is to solve this problem!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data types and variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to write programms so we can perform calculations on data. For instance, to answer the question above, we want to deal with the strings \"GATTACA\" and \"GACTATA\". We can tell the program to keep these strings in memory by assigning them to a **variable**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "A variable is just a name for a value,\n",
    "such as `x`, `current_temperature`, or `subject_id`.\n",
    "We can create a new variable simply by assigning a value to it using `=`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:06.254134",
     "start_time": "2017-07-23T05:26:06.240761Z"
    }
   },
   "outputs": [],
   "source": [
    "dna_string = \"GACTATA\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once a variable has a value, we can print it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:06.740218",
     "start_time": "2017-07-23T05:26:06.734639Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GACTATA\n"
     ]
    }
   ],
   "source": [
    "print(dna_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we told Python that \"GACTATA\" is our string data by putting quotes around it. The variable names do not need quotes.\n",
    "\n",
    "The value we assign to a variable does not need to be a string. It could be a number, for instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:07.226320",
     "start_time": "2017-07-23T05:26:07.220464Z"
    },
    "cell_tags": []
   },
   "outputs": [],
   "source": [
    "weight_kg = 55"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "Just as before, now the variable has a value, we can print it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:07.875391",
     "start_time": "2017-07-23T05:26:07.867706Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "print(weight_kg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "and since it's a number, we can do arithmetic with it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:08.506301",
     "start_time": "2017-07-23T05:26:08.500978Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight in pounds: 121.00000000000001\n"
     ]
    }
   ],
   "source": [
    "print('weight in pounds:', 2.2 * weight_kg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "We can also change a variable's value by assigning it a new one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:09.146902",
     "start_time": "2017-07-23T05:26:09.141338Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight in kilograms is now: 57.5\n"
     ]
    }
   ],
   "source": [
    "weight_kg = 57.5\n",
    "print('weight in kilograms is now:', weight_kg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "As the example above shows,\n",
    "we can print several things at once by separating them with commas.\n",
    "\n",
    "If we imagine the variable as a sticky note with a name written on it,\n",
    "assignment is like putting the sticky note on a particular value:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "<img src=\"img/python-sticky-note-variables-01.svg\" alt=\"Variables as Sticky Notes\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "This means that assigning a value to one variable does *not* change the values of other variables.\n",
    "For example,\n",
    "let's store the subject's weight in pounds in a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:10.450819",
     "start_time": "2017-07-23T05:26:10.445485Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight in kilograms: 57.5 and in pounds: 126.50000000000001\n"
     ]
    }
   ],
   "source": [
    "weight_lb = 2.2 * weight_kg\n",
    "print('weight in kilograms:', weight_kg, 'and in pounds:', weight_lb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/python-sticky-note-variables-02.svg\" alt=\"Creating Another Variable\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "and then change `weight_kg`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:11.497662",
     "start_time": "2017-07-23T05:26:11.490458Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight in kilograms is now: 100.0 and weight in pounds is still: 126.50000000000001\n"
     ]
    }
   ],
   "source": [
    "weight_kg = 100.0\n",
    "print('weight in kilograms is now:', weight_kg, 'and weight in pounds is still:', weight_lb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/python-sticky-note-variables-03.svg\" alt=\"Updating a Variable\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": [
     "challenges"
    ]
   },
   "source": [
    "#### Challenges\n",
    "\n",
    "1.  Draw diagrams showing what variables refer to what values after each statement in the following program:\n",
    "\n",
    "    ~~~python\n",
    "    mass = 47.5\n",
    "    age = 122\n",
    "    mass = mass * 2.0\n",
    "    age = age - 20\n",
    "    ~~~\n",
    "\n",
    "1.  Think and answer: what would the following program print out?\n",
    "\n",
    "    ~~~python\n",
    "    first = 3\n",
    "    second = 7\n",
    "    first = 2\n",
    "    print(first, second)\n",
    "    ~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data can be of different types, and this is important when programming. For instance, you can do arithmetic with the variable `weight_kg` because it is a number. If you try to do arithmetic with `dna_string` you will get an error, as this doesn't make sense for strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:13.253044",
     "start_time": "2017-07-23T05:26:13.242814Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50.0\n"
     ]
    }
   ],
   "source": [
    "print(weight_kg / 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:14.756068",
     "start_time": "2017-07-23T05:26:14.555615Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-dc5dcd030843>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdna_string\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "print(dna_string / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that in this error message, Python is complaining that the variable was of the wrong *type* to do division.\n",
    "\n",
    "You can see the type of a variable yourself, using Python's built-in `type()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:18.322497",
     "start_time": "2017-07-23T05:26:18.316624Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means that x is an integer. \n",
    "\n",
    "Numbers can also be \"floating point\" numbers, which means they have a decimal part:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:19.467980",
     "start_time": "2017-07-23T05:26:19.461877Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 5.5\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And of course, our data can be strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:20.374182",
     "start_time": "2017-07-23T05:26:20.368363Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(dna_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To solve the Hamming distance problem, we can see we're going to need to deal with strings, since that's the input data. We can also see we're going to need numerical variables, since the output we want from our program is the number of positions which differ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A bit of terminology: *strings* are made of single-letter *characters*. For instance, the string \"3 dogs!\" is made of the characters `'3', ' ', 'd', 'o', 'g', 's'`, and `'!'`. Notice that the space and the punctuation count as characters too.\n",
    "\n",
    "Characters, like strings, should always be enclosed in quotes to distinguish them from variable names and from Python's special keywords. \n",
    "\n",
    "Python considers characters to be just single-letter strings, so it gives them type 'str':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:21.116034",
     "start_time": "2017-07-23T05:26:21.109788Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "char = 'C'\n",
    "print(type(char))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are reusable pieces of a program. Let's look at some examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll start by defining a function `celsius_to_kelvin` that converts temperatures from degrees Celsius to Kelvin:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:23.473908",
     "start_time": "2017-07-23T05:26:23.468476Z"
    }
   },
   "outputs": [],
   "source": [
    "def celsius_to_kelvin(celsius_temp):\n",
    "    kelvin_temp = celsius_temp + 273.15\n",
    "    return kelvin_temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The definition opens with the word `def`,\n",
    "which is followed by the name of the function\n",
    "and a parenthesized list of parameter names.\n",
    "The [body](gloss.html#function-body) of the function&mdash;the\n",
    "statements that are executed when it runs&mdash;is indented below the definition line,\n",
    "typically by four spaces.\n",
    "\n",
    "When we call the function,\n",
    "the values we pass to it are assigned to those variables\n",
    "so that we can use them inside the function.\n",
    "Inside the function,\n",
    "we use a [return statement](gloss.html#return-statement) to send a result back to whoever asked for it. \n",
    "\n",
    "Let's try running our function.\n",
    "Calling our own function is no different from calling any other function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:24.382385",
     "start_time": "2017-07-23T05:26:24.375243Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "freezing point of water: 273.15\n",
      "boiling point of water: 373.15\n"
     ]
    }
   ],
   "source": [
    "print('freezing point of water:', celsius_to_kelvin(0))\n",
    "print('boiling point of water:', celsius_to_kelvin(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can take more than one argument. For instance, here's a function which calculates the difference between two temperatures:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:25.104502",
     "start_time": "2017-07-23T05:26:25.098314Z"
    }
   },
   "outputs": [],
   "source": [
    "def temperature_difference(temp1, temp2):\n",
    "    difference = temp1 - temp2\n",
    "    return difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we run this function, the values we give it are assigned (in order) to `temp1` and `temp2`, and then the body of the function is executed, and the value returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:25.924225",
     "start_time": "2017-07-23T05:26:25.919123Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "print(temperature_difference(21,12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:26.315764",
     "start_time": "2017-07-23T05:26:26.310627Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-9\n"
     ]
    }
   ],
   "source": [
    "print(temperature_difference(12,21))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function doesn't have to have a return statement. For instance we might want to write a function that does something directly, like print to the screen. It doesn't need to return anything, so there's no need for a return statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:27.200586",
     "start_time": "2017-07-23T05:26:27.195586Z"
    }
   },
   "outputs": [],
   "source": [
    "def write_announcement(winner):\n",
    "    print(f\"We are glad to announce that {winner} has won the contest!\")\n",
    "    print(f\"Please congratulate {winner}!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:27.608818",
     "start_time": "2017-07-23T05:26:27.603925Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are glad to announce that Clare has won the contest!\n",
      "Please congratulate Clare!\n"
     ]
    }
   ],
   "source": [
    "write_announcement(\"Clare\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By the way, the letter `f` before the string, and the `{winner)` variable inside the string, are an example of \"f-strings\", which are new in Python 3.6. You may also see the `.format()` function used for string formatting. We won't go into this just yet, but you can ask your demonstrator if you're interested.\n",
    "\n",
    "Because our `write_announcement` function has no `return` statement, it will actually return the special value `None`. This is not a string but a special type that tells Python that the variable has no value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:28.474120",
     "start_time": "2017-07-23T05:26:28.468082Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are glad to announce that Andrew has won the contest!\n",
      "Please congratulate Andrew!\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "result = write_announcement(\"Andrew\")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Challenge\n",
    "\n",
    "Define a function, and name it `double`. Write the function so that it takes in a single number as a parameter, and returns double that number. Once you've defined the function, some example output should look like this:\n",
    "\n",
    "~~~python\n",
    "print(double(3))\n",
    "6\n",
    "print(double(532))\n",
    "1064\n",
    "~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals: making choices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to be able to write programs that do different things depending on what data they are given.\n",
    "\n",
    "For instance, to be able to calculate the Hamming distance, we need to do something different depending on whether each letter does or does not match the corresponding letter in the other string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tool Python gives us for doing this is called a conditional statement, and looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:30.409001",
     "start_time": "2017-07-23T05:26:30.399029Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not greater\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "num = 37\n",
    "if num > 100:\n",
    "    print('greater')\n",
    "else:\n",
    "    print('not greater')\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second line of this code uses the keyword `if` to tell Python that we want to make a choice.\n",
    "If the test that follows it is true,\n",
    "the body of the `if`\n",
    "(i.e., the lines indented underneath it) are executed.\n",
    "If the test is false,\n",
    "the body of the `else` is executed instead.\n",
    "Only one or the other is ever executed:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/python-flowchart-conditional.svg\" alt=\"Executing a Conditional\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditional statements don't have to include an `else`.\n",
    "If there isn't one,\n",
    "Python simply does nothing if the test is false:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:31.883403",
     "start_time": "2017-07-23T05:26:31.874645Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before conditional...\n",
      "...after conditional\n"
     ]
    }
   ],
   "source": [
    "num = 53\n",
    "print('before conditional...')\n",
    "if num > 100:\n",
    "    print('53 is greater than 100')\n",
    "print('...after conditional')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also chain several tests together using `elif`,\n",
    "which is short for \"else if\".\n",
    "This makes it simple to write a function that returns the sign of a number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:32.682135",
     "start_time": "2017-07-23T05:26:32.667364Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sign of -3 is -1\n"
     ]
    }
   ],
   "source": [
    "def sign(num):\n",
    "    if num > 0:\n",
    "        return 1\n",
    "    elif num == 0:\n",
    "        return 0\n",
    "    else:\n",
    "        return -1\n",
    "\n",
    "print(\"sign of -3 is\", sign(-3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One important thing to notice in the code above is that we use a double equals sign `==` to test for equality rather than a single equals sign,\n",
    "because the latter is used to mean assignment. So\n",
    "\n",
    "    num = 5\n",
    "\n",
    "changes `num` to be equal to `5`, while\n",
    "\n",
    "    num == 5\n",
    "\n",
    "doesn't change `num` at all, but returns `True` or `False` depending on whether `num` is equal to `5`.\n",
    "\n",
    "The operator for \"is not equal\" is also not obvious: it's `!=`, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:33.509477",
     "start_time": "2017-07-23T05:26:33.502436Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is not 37\n"
     ]
    }
   ],
   "source": [
    "num = 5\n",
    "if num != 37:\n",
    "    print(\"The number is not 37\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also combine tests using `and` and `or`.\n",
    "`and` is only true if both parts are true:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:34.261804",
     "start_time": "2017-07-23T05:26:34.253071Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one statement is not true\n"
     ]
    }
   ],
   "source": [
    "if (1 > 0) and (-1 > 0):\n",
    "    print('both statements are true')\n",
    "else:\n",
    "    print('one statement is not true')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`or` is true if either part is true:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:35.027125",
     "start_time": "2017-07-23T05:26:35.020978Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one test is true\n"
     ]
    }
   ],
   "source": [
    "if (1 < 0) or ('left' < 'right'):\n",
    "    print('at least one test is true')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For `or` statements, \"either\" means \"either or both\", not \"either one or the other but not both\".\n",
    "\n",
    "By the way, why is `\"left\" < \"right\"`? When we ask Python to compare numbers, it considers the smaller number to be less than the bigger number; when we ask Python to compare *strings*, it looks at their alphabetical ordering. `\"l\"` comes before `\"r\"` in the alphabet, so this comparison returns `True`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### True and False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has special values called `True` and `False`, which are what is returned if we evaluate a comparison. For our first example, we wrote an if statement which looked like\n",
    "\n",
    "~~~python\n",
    "num = 37\n",
    "if num > 100:\n",
    "    ...\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, `num` was not more than `100` in this case. What if we look directly at the result of that comparison?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:36.885055",
     "start_time": "2017-07-23T05:26:36.880469Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "num = 37\n",
    "print(num > 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`False` is not a string - it's a special Python value that literally means false, or not true. There's also `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:37.585590",
     "start_time": "2017-07-23T05:26:37.579573Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "num = 121\n",
    "print(num > 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Challenge\n",
    "\n",
    "1.  To calculate the Hamming distance, we will need to be able to test if characters are the same. In fact the simplest Hamming distance calculation is between just two characters, for instance:\n",
    "\n",
    "        G\n",
    "        G\n",
    "\n",
    "    Here the characters are the same, so the Hamming distance is zero.\n",
    "\n",
    "        G\n",
    "        T\n",
    "\n",
    "    Here the characters are different, so the Hamming distance is 1.\n",
    "\n",
    "    Define a function called `character_distance` which takes two parameters and returns 1 if the two characters are different, and 0 if they are the same. Some example output should look like:\n",
    "\n",
    "    ~~~python\n",
    "    print(character_distance(\"G\", \"G\"))\n",
    "    0\n",
    "\n",
    "    print(character_distance(\"A\", \"T\"))\n",
    "    1\n",
    "    ~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating many things: for loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A big advantage of writing a program is that we only need to write it once, but can run it again and again, saving effort."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we need to run an algorithm thousands or millions of times, we don't want to have to call it each time. So, we need to be able to tell the computer to repeat things."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we want to print each character in the sequence \"GACT\" on a line of its own. We can specify a character of a string using square brackets `[]`. If the variable that holds the string is called `s`, then `s[0]` is the first character, `s[1]` is the second character, and so on. This is called string indexing.\n",
    "\n",
    "So, one way to print out each character of the string would be to use four `print` statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:39.632335",
     "start_time": "2017-07-23T05:26:39.624872Z"
    }
   },
   "outputs": [],
   "source": [
    "def print_characters(s):\n",
    "    print(s[0])\n",
    "    print(s[1])\n",
    "    print(s[2])\n",
    "    print(s[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:40.637442",
     "start_time": "2017-07-23T05:26:40.631765Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "G\n",
      "A\n",
      "C\n",
      "T\n"
     ]
    }
   ],
   "source": [
    "print_characters('GACT')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but that's a bad approach for two reasons:\n",
    "\n",
    "1.  It doesn't scale:\n",
    "    if we want to print the characters in a string that's hundreds of letters long,\n",
    "    we'd be better off just typing them in.\n",
    "\n",
    "1.  It's fragile:\n",
    "    if we give it a longer string,\n",
    "    it only prints part of the data,\n",
    "    and if we give it a shorter one,\n",
    "    it produces an error because we're asking for characters that don't exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:26:41.395527",
     "start_time": "2017-07-23T05:26:41.363685Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "A\n",
      "T\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-35bac565a5ec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint_characters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"CAT\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-31-3846d08d71a9>\u001b[0m in \u001b[0;36mprint_characters\u001b[0;34m(s)\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "print_characters(\"CAT\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a better approach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:43.869446",
     "start_time": "2017-07-23T05:27:43.840235Z"
    }
   },
   "outputs": [],
   "source": [
    "def print_characters(s):\n",
    "    for char in s:\n",
    "        print(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:44.396665",
     "start_time": "2017-07-23T05:27:44.389658Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "G\n",
      "A\n",
      "C\n",
      "T\n"
     ]
    }
   ],
   "source": [
    "print_characters('GACT')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is shorter---certainly shorter than something that prints every character in a hundred-letter string---and\n",
    "more robust as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:45.522423",
     "start_time": "2017-07-23T05:27:45.515232Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o\n",
      "x\n",
      "y\n",
      "g\n",
      "e\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "print_characters('oxygen')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might be able to see how this ability to do something with each character in turn, no matter how long the string, will be useful in solving our Hamming distance problem!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The improved version of `print_characters` uses a [for loop](gloss.html#for-loop)\n",
    "to repeat an operation---in this case, printing---once for each thing in a collection.\n",
    "The general form of a loop is:\n",
    "\n",
    "<pre>\n",
    "<strong>for</strong> <em>variable</em> <strong>in</strong> <em>collection</em><strong>:</strong>\n",
    "    <em>do things with variable</em>\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can call the [loop variable](gloss.html#loop-variable) anything we like,\n",
    "but there must be a colon at the end of the line starting the loop,\n",
    "and we must indent the body of the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's another loop that repeatedly updates a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:47.862936",
     "start_time": "2017-07-23T05:27:47.847439Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 5 vowels\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "for vowel in \"aeiou\":\n",
    "    count = count + 1\n",
    "print(\"There are\",count,\"vowels\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's worth tracing the execution of this little program step by step.\n",
    "Since there are five characters in `'aeiou'`,\n",
    "the statement on line 3 will be executed five times.\n",
    "The first time around,\n",
    "`count` is zero (the value assigned to it on line 1)\n",
    "and `vowel` is `'a'`.\n",
    "The statement adds 1 to the old value of `count`,\n",
    "producing 1,\n",
    "and updates `count` to refer to that new value.\n",
    "The next time around,\n",
    "`vowel` is `'e'` and `count` is 1,\n",
    "so `count` is updated to be 2.\n",
    "After three more updates,\n",
    "`count` is 5;\n",
    "since there is nothing left in `'aeiou'` for Python to process,\n",
    "the loop finishes\n",
    "and the `print` statement on line 4 tells us our final answer.\n",
    "\n",
    "Note that a loop variable is just a variable that's being used to record progress in a loop.\n",
    "It still exists after the loop is over,\n",
    "and we can re-use variables previously defined as loop variables as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:48.799553",
     "start_time": "2017-07-23T05:27:48.789922Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "after the loop, letter is c\n"
     ]
    }
   ],
   "source": [
    "letter = 'z'\n",
    "for letter in 'abc':\n",
    "    print(letter)\n",
    "print('after the loop, letter is', letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note also that finding the length of a string is such a common operation\n",
    "that Python actually has a built-in function to do it called `len`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:49.823450",
     "start_time": "2017-07-23T05:27:49.817327Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(len(\"aeiou\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Built-in functions like `len` are often much faster than functions we write ourselves,\n",
    "and much easier to read;\n",
    "`len` will also give us the length of many other things that we haven't met yet,\n",
    "so it is the better option here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Challenge (hard)\n",
    "\n",
    "Loops can also be nested: if you put a `for` loop inside a `for` loop, every pass through the outer loop will do an entire run-through of all values of the inner loop.\n",
    "\n",
    "Using nested loops, write a Python program to write out every two-letter combination of A,C,G and T. The output should look like:\n",
    "\n",
    "    A A\n",
    "    A C\n",
    "    A G\n",
    "    A T\n",
    "    C A\n",
    "    C C\n",
    "    C G\n",
    "    C T\n",
    "    G A\n",
    "    G C\n",
    "    G G\n",
    "    G T\n",
    "    T A\n",
    "    T C\n",
    "    T G\n",
    "    T T\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's think about `for` loops for solving our Hamming distance problem. We saw above how to loop over the characters in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:51.723265",
     "start_time": "2017-07-23T05:27:51.713281Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "G\n",
      "A\n",
      "C\n",
      "T\n"
     ]
    }
   ],
   "source": [
    "def print_characters(my_string):\n",
    "    for char in my_string:\n",
    "        print(char)\n",
    "\n",
    "print_characters(\"GACT\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For Hamming distance, we need to compare each character in one string to the corresponding character in the other. We might think about applying a loop go through each character in turn. Given\n",
    "\n",
    "    GATTACA\n",
    "    GACTATA\n",
    "\n",
    "we could use a loop to compare `G` to `G`, then `A` to `A`, then `C` to `T`, and so on.\n",
    "\n",
    "But to do this we need to be able to loop over both strings at once. How can we do this? To understand one way to do it, we'll first learn about lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists and loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "Just as a `for` loop is a way to do operations many times,\n",
    "a list is a way to store many values.\n",
    "We create a list by putting values inside square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:53.562008",
     "start_time": "2017-07-23T05:27:53.555257Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "odd numbers are: [1, 3, 5, 7, 9, 11]\n"
     ]
    }
   ],
   "source": [
    "odds = [1, 3, 5, 7, 9, 11]\n",
    "print('odd numbers are:', odds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "Just like characters in a string, we select individual elements from lists by indexing them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:54.408886",
     "start_time": "2017-07-23T05:27:54.402866Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first and last: 1 11\n"
     ]
    }
   ],
   "source": [
    "print('first and last:', odds[0], odds[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:54.848016",
     "start_time": "2017-07-23T05:27:54.842649Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first, third and fourth: 1 5 7\n"
     ]
    }
   ],
   "source": [
    "print('first, third and fourth:', odds[0], odds[2], odds[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "and if we loop over a list,\n",
    "the loop variable is assigned elements one at a time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:55.675010",
     "start_time": "2017-07-23T05:27:55.669355Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "for number in odds:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "There is one important difference between lists and strings:\n",
    "we can change the values in a list,\n",
    "but we cannot change the characters in a string.\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:56.426258",
     "start_time": "2017-07-23T05:27:56.418695Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "names is originally: ['Newton', 'Darwing', 'Turing']\n",
      "final value of names: ['Newton', 'Darwin', 'Turing']\n"
     ]
    }
   ],
   "source": [
    "names = ['Newton', 'Darwing', 'Turing'] # typo in Darwin's name\n",
    "print('names is originally:', names)\n",
    "names[1] = 'Darwin' # correct the name\n",
    "print('final value of names:', names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "works, but this doesn't:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:27:57.131485",
     "start_time": "2017-07-23T05:27:57.118572Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-46-220df48aeb2e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Bell'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mname\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'b'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "name = 'Bell'\n",
    "name[0] = 'b'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a useful built-in function called `range` that creates a list of the first $N$ numbers starting from zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:28:14.231899",
     "start_time": "2017-07-23T05:28:14.226055Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:28:14.975548",
     "start_time": "2017-07-23T05:28:14.970481Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we had to use `list()` to see the contents of `range(3)`. This is because `range()` actually returns an *iterator*, a fairly advanced topic that we won't cover yet. `list()` converts our iterator into a list so that we can print it out."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`range()` is particularly useful with `for` loops! For instance to write something out 5 times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:28:53.649265",
     "start_time": "2017-07-23T05:28:53.643325Z"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "EOL while scanning string literal (<ipython-input-50-cedd704b721c>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-50-cedd704b721c>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    print(\"Hello!)\u001b[0m\n\u001b[0m                  ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(\"Hello!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Challenges\n",
    "\n",
    "1.  Using `range`, write a function that prints the $N$ natural numbers, i.e. counting from $1$:\n",
    "    \n",
    "    ~~~python\n",
    "    print_N(3)\n",
    "    1\n",
    "    2\n",
    "    3\n",
    "    ~~~\n",
    "\n",
    "2.  Write a function which takes two strings, and prints out the first characters of both strings on the first line, the second characters of both strings on the second line, and so on. \n",
    "\n",
    "    ~~~python\n",
    "    print_pairs(\"CAT\",\"DOG\")\n",
    "    C D\n",
    "    A O\n",
    "    T G\n",
    "    ~~~\n",
    "    \n",
    "    Hints:\n",
    "    \n",
    "    - remember that you can get the length of a string using the built-in `len()` function\n",
    "    - remember that you can use a character from a string by indexing it, like `s[0]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Putting it all together: nesting loops and conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "Another thing to realize is that `if` and `for` statements can be combined with one another \n",
    "just as easily as they can be combined with functions.\n",
    "For example,\n",
    "if we want to sum only the positive numbers in a list,\n",
    "we can write this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:29:00.837095",
     "start_time": "2017-07-23T05:29:00.825849Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum of positive values: 20\n"
     ]
    }
   ],
   "source": [
    "numbers = [-5, 3, 2, -1, 9, 6]\n",
    "total = 0\n",
    "for n in numbers:\n",
    "    if n >= 0:\n",
    "        total = total + n\n",
    "print('sum of positive values:', total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "We could equally well calculate the positive and negative sums in a single loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:29:01.953631",
     "start_time": "2017-07-23T05:29:01.940341Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "negative and positive sums are: -6 20\n"
     ]
    }
   ],
   "source": [
    "pos_total = 0\n",
    "neg_total = 0\n",
    "for n in numbers:\n",
    "    if n >= 0:\n",
    "        pos_total = pos_total + n\n",
    "    else:\n",
    "        neg_total = neg_total + n\n",
    "print('negative and positive sums are:', neg_total, pos_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "We can even put one loop inside another:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-23T05:29:02.942346",
     "start_time": "2017-07-23T05:29:02.935602Z"
    },
    "cell_tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ba\n",
      "be\n",
      "ca\n",
      "ce\n",
      "da\n",
      "de\n"
     ]
    }
   ],
   "source": [
    "for consonant in 'bcd':\n",
    "    for vowel in 'ae':\n",
    "        print(consonant + vowel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "As the diagram below shows,\n",
    "the [inner loop](gloss.html#inner-loop) runs from start to finish\n",
    "each time the [outer loop](gloss.html#outer-loop) runs once:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_tags": []
   },
   "source": [
    "<img src=\"img/python-flowchart-nested-loops.svg\" alt=\"Execution of Nested Loops\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Challenge\n",
    "\n",
    "Write a function to count the number of 'C's and 'G's in a DNA sequence. Some sample output should look like:\n",
    "\n",
    "~~~python\n",
    "print(count_CG(\"GATTACA\"))\n",
    "2\n",
    "print(count_CG(\"ACAAAACAGCGAACACTCGC\"))\n",
    "10\n",
    "~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final challenge!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function which takes in two strings as parameters, and returns the Hamming distance between them. You can assume the input strings are the same length."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some sample output should look like this (you can cut and paste these strings to check you get the same answers):\n",
    "\n",
    "~~~python\n",
    "print(hamming_distance(\"GATTACA\",\"GACTATA\"))\n",
    "2\n",
    "print(hamming_distance(\"CAT\",\"DOG\"))\n",
    "3\n",
    "print(hamming_distance(\"CAT\", \"ACT\"))\n",
    "2\n",
    "print(hamming_distance(\"GTTCTTGGACGACGAAAAGA\", \"GTTCGTGAGGCCACATCCCG\"))\n",
    "13\n",
    "print(hamming_distance(\"GTGCTTCCAGTCACGCTGTCTTGGGGTAGC\", \"TCGAGCAGTATCACATTACTAAGGATGTGC\"))\n",
    "20\n",
    "print(hamming_distance(\"GCGAGCCCAGTCACGCTGTCTTGGGGTAGC\", \"TCGAGCAGTATCACGCTACTAAGGGGGTGC\"))\n",
    "12\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you can get this working, well done! This is our first bioinformatics algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.5"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "315px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}