Introduction_to_python_day_1_session_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# An introduction to solving biological problems with Python\n",
    "\n",
    "## Session 1.3: Conditional execution\n",
    "\n",
    "- [Code blocks](#Code-blocks)\n",
    "- [Conditional execution](#Conditional-execution)\n",
    "- [Exercises 1.3.1](#Exercises-1.3.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Program control and logic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A program will normally run by executing the stated commands, one after the other in sequential order. Frequently however, you will need the program to deviate from this. There are several ways of diverting from the line-by-line paradigm:\n",
    "\n",
    "- With conditional statements. Here you can check if some statement or expression is true, and if it is then you continue on with the following block of code, otherwise you might skip it or execute a different bit of code.\n",
    "\n",
    "- By performing repetitive loops through the same block of code, where each time through the loop different values may be used for the variables.\n",
    "\n",
    "- Through the use of functions (subroutines) where the program’s execution jumps from a particular line of code to an entirely different spot, even in a different file or module, to do a task before (usually) jumping back again. Functions are covered in the next session, so we will not discuss them yet.\n",
    "\n",
    "- By checking if an error or exception occurs, i.e. something illegal has happened, and executing different blocks of code accordingly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code blocks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With all of the means by which Python code execution can jump about we naturally need to be aware of the boundaries of the block of code we jump into, so that it is clear at what point the job is done, and program execution can jump back again. In essence it is required that the end of a function, loop or conditional statement be defined, so that we know the bounds of their respective code blocks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python uses indentation to show which statements are in a block of code, other languages use specific `begin` and `end` statements or curly braces `{}`. It doesn't matter how much indentation you use, but the whole block must be consistent, i.e., if the first statement is indented by four spaces, the rest of the block must be indented by the same amount. The Python style guide recommends using 4-space indentation. Use spaces, rather than tabs, since different editors display tab characters with different widths.\n",
    "\n",
    "The use of indentation to delineate code blocks is illustrated in an abstract manner in the following scheme: \n",
    "\n",
    "Statement 1:\n",
    "\n",
    "    Command A – in the block of statement 1\n",
    "    Command B – in the block of statement 1\n",
    "  \n",
    "    Statement 2:\n",
    "        Command C – in the block of statement 2\n",
    "        Command D – in the block of statement 2\n",
    "  \n",
    "    Command E – back in the block of statement 1\n",
    "\n",
    "Command F – outside all statement blocks\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional execution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The <tt>if</tt> statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A conditional <tt>if</tt> statement is used to specify that some block of code should only be executed if some associated test is upheld; a conditional expression evaluates to <tt>True</tt>. This might also involve subsidiary checks using the <tt>elif</tt> statement to use an alternative block if the previous expression turns out to be False. There can even be a final <tt>else</tt> statement to do something if none of the checks are passed. \n",
    "\n",
    "The following uses statements that test whether a number is less than zero, greater than zero or otherwise equal to zero and will print out a different message in each case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = -3\n",
    "\n",
    "if x > 0:\n",
    "  print(\"Value is positive\")\n",
    "\n",
    "elif x < 0:\n",
    "  print(\"Value is negative\")\n",
    "\n",
    "else:\n",
    "  print(\"Value is zero\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The general form of writing out such combined conditional statements is as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "if conditionalExpression1:\n",
    "    # codeBlock1\n",
    "\n",
    "elif conditionalExpression2:\n",
    "    # codeBlock2\n",
    "\n",
    "elif conditionalExpressionN:\n",
    "    # codeBlockN\n",
    "    +any number of additional elif statements, then finally:\n",
    "\n",
    "else:\n",
    "    # codeBlockE\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The <tt>elif</tt> block is optional, and we can use as many as we like. The <tt>else</tt> block is also optional, so will only have the <tt>if</tt> statement, which is a fairly common situation. It is often good practice to include <tt>else</tt> where possible though, so that you always catch cases that do not pass, otherwise values might go unnoticed, which might not be the desired behaviour."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Placeholders are needed for “empty” code blocks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "gene = \"BRCA2\"\n",
    "geneExpression = -1.2\n",
    "\n",
    "if geneExpression < 0:\n",
    "    print(gene, \"is downregulated\")\n",
    "        \n",
    "elif geneExpression > 0:\n",
    "    print(gene, \"is upregulated\")\n",
    "        \n",
    "else:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For very simple conditional checks, you can write the `if` statement on a single line as a single expression, and the result will be the expression before the `if` if the condition is true or the expression after the `else` otherwise.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 11\n",
    "\n",
    "if x < 10:\n",
    "    s = \"Yes\"\n",
    "else:\n",
    "    s = \"No\"\n",
    "print(s)\n",
    "\n",
    "# Could also be written onto one line\n",
    "s = \"Yes\" if x < 10 else \"No\"\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparisons and truth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With conditional execution the question naturally arises as to which expressions are deemed to be true and which false. For the python boolean values <tt>True</tt> and <tt>False</tt> the answer is (hopefully) obvious. Also, the logical states of truth and falsehood that result from conditional checks like “Is x greater than 5?” or “Is y in this list?” are also clear. When comparing values Python has the standard comparison (or relational) operators, some of which we have already seen:\n",
    "\n",
    "|Operator |\tDescription |\tExample |\n",
    "|---------|-------------|-----------|\n",
    "|`==`  |\t    equality |\t1 == 2 # False |\n",
    "|`!=`  |\t    non equality |\t1 != 2 # True |\n",
    "| `<`  |\t    less than |\t1 < 2 # True |\n",
    "| `<=` |\t    equal or less than |\t2 <= 2 # True |\n",
    "| `>`  |\t    greater then |\t1 > 2 # False |\n",
    "| `>=` |\t    equal or greater than |\t1 >= 1 # True |\n",
    "\n",
    "It is notable that comparison operations can be combined, for example to check if a value is within a range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = -5\n",
    "\n",
    "if x > 0 and x < 10:\n",
    "    print(\"In range A\")\n",
    "    \n",
    "elif x < 0 or x > 10:\n",
    "    print(\"In range B\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has two additional comparison operators <tt>is</tt> and <tt>is not</tt>. These compare whether two objects are the same object, whereas <tt>==</tt> and <tt>!=</tt> compare whether values are the same.\n",
    "\n",
    "As an example in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = [123, 54, 92, 87, 33]\n",
    "y = x[:] # y is a copy of x\n",
    "z = x\n",
    "print(x)\n",
    "print(\"Are values of y and x the same?\", y == x)\n",
    "print(\"Are objects y and x the same?\", y is x)\n",
    "print(\"Are values of z and x the same?\", z == x)\n",
    "print(\"Are objects z and x the same?\", z is x)\n",
    "# Let's change x\n",
    "x[1] = 23\n",
    "print(x)\n",
    "print(\"Are values of y and x the same?\", y == x)\n",
    "print(\"Are objects y and x the same?\", y is x)\n",
    "print(\"Are values of z and x the same?\", z == x)\n",
    "print(\"Are objects z and x the same?\", z is x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python even expressions that do not involve an obvious boolean value can be assigned a status of \"truthfulness\";  the value of an item itself can be forced to be considered as either True or False inside an if statement. For the Python built-in types discussed in this chapter the following are deemed to be False in such a context:\n",
    "\n",
    "| False value | Description | \n",
    "|-------------|-------------|\n",
    "| `None` |\tnumeric equality |\n",
    "| `False` |\tFalse boolean |\n",
    "| `0`\t| 0 integer |\n",
    "| `0.0` |\t0.0 floating point |\n",
    "| `\"\"` |\tempty string |\n",
    "| `()` |\tempty tuple |\n",
    "| `[]` |\tempty list |\n",
    "| `{}` |\tempty dictonary |\n",
    "| `set()` |\tempty set |\n",
    "\n",
    "And everything else is deemed to be True in a conditional context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = ''      # An empty string\n",
    "y = ['a']   # A list with one item\n",
    "\n",
    "if x:\n",
    "    print(\"x is true\")\n",
    "else: \n",
    "    print(\"x is false\")     \n",
    "\n",
    "if y:\n",
    "    print(\"y is true\")\n",
    "else:\n",
    "    print(\"y is false\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises 1.3.1\n",
    "\n",
    "1. (a) Create a `if..elif..else` block that will compare a variable containing your age to another variable containing another person's age and print a statement which says if you are younger, older or the same age as that person.\n",
    "2. (b) Use an `if` statement to check if some variable containing DNA sequence contains a stop codon. (e.g. `dna = \"ATGGCGGTCGAATAG\"`), first just check for one possible stop, but then extend your code to look for any of the 3 stop codons (`TAG`, `TAA`, `TGA`). Hint: recall that the `in` operator lets you check if a string contains some substring, and returns `True` or `False` accordingly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next session\n",
    "\n",
    "Go to our next notebook: [Introduction_to_python_day_1_session_4](Introduction_to_python_day_1_session_4.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}