Python/Python_Lesson_05.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wjZKXZ9dXJUr"
   },
   "source": [
    "<a name=\"top\"></a>\n",
    "\n",
    "# Introduction to Python Programming for Bioinformatics. Lesson 5\n",
    "\n",
    "<details>\n",
    "<summary>\n",
    "About this notebook\n",
    "</summary>\n",
    "\n",
    "This notebook was originally written by [Marc Cohen](https://github.com/mco-gh), an engineer at Google. The original source can be found on [Marc's short link service](https://mco.fyi/), and starts with [Python lesson 0](https://mco.fyi/py0), and I encourage you to work through that notebook if you find some details missing here.\n",
    "\n",
    "Rob Edwards edited the notebook, adapted it for bioinformatics, using some simple geneticy examples, condensed it into a single notebook, and rearranged some of the lessons, so if some of it does not make sense, it is Rob's fault!\n",
    "\n",
    "It is intended as a hands-on companion to an in-person course, and if you would like Rob to teach this course (or one of the other courses) don't hesitate to get in touch with him.\n",
    "\n",
    "</details>\n",
    "<details>\n",
    "<summary>\n",
    "Using this notebook\n",
    "</summary>\n",
    "\n",
    "You can download the original version of this notebook from [GitHub](https://linsalrob.github.io/ComputationalGenomicsManual/Python/Python_Lesson_05.ipynb) and from [Rob's Google Drive]()\n",
    "\n",
    "**You should make your own copy of this notebook by selecting File->Save a copy in Drive from the menu bar above, and then you can edit the code and run it as your own**\n",
    "\n",
    "There are several lessons, and you can do them in any order. I've tried to organise them in the order I think most appropriate, but you may disagree!\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_Km_oeNBXJUy"
   },
   "source": [
    "<a name=\"lessons\"></a>\n",
    "\n",
    "# Lesson Links\n",
    "\n",
    "* [Lesson 5 - Conditionals](#Lesson-5---Conditionals)\n",
    "  * [Controlling Program Flow](#Controlling-Program-Flow)\n",
    "  * [if Statements](#if-Statements)\n",
    "  * [if Block Structure](#if-Block-Structure)\n",
    "  * [Python's use of whitespace](#Python's-use-of-whitespace)\n",
    "  * [else Statements](#else-Statements)\n",
    "  * [elif Statements](#elif-Statements)\n",
    "  * [For loops](#For-loops)\n",
    "\n",
    "Previous Lesson: [Local](Python_Lesson_04.ipynb) | [GitHub](https://linsalrob.github.io/ComputationalGenomicsManual/Python/Python_Lesson_04.ipynb) | [Google Colab](https://colab.research.google.com/drive/1IyjNTpdtwaulP_QXbrCYK8Yd2J3MgCQo)\n",
    "\n",
    "Next Lesson: [Local](Python_Lesson_06.ipynb) | [GitHub](https://linsalrob.github.io/ComputationalGenomicsManual/Python/Python_Lesson_06.ipynb) | [Google Colab](https://colab.research.google.com/drive/1iLE4rkhVxige0za_H0ehtb9NNzzxQIwu)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rLNA879cXJVN",
    "lines_to_next_cell": 2
   },
   "source": [
    "# Lesson 5 - Conditionals\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KiBaxNk9bAVl"
   },
   "source": [
    "# Controlling Program Flow\n",
    "\n",
    "Question:\n",
    "\n",
    "Does an stretch of DNA 2329 bp long encode a gene?\n",
    "\n",
    "* Up to now, we've looked at very simple programs, involving a sequence of statements (A, then B, then C…)\n",
    "* But what you really want to do is probably a lot more complex than adding numbers or simple statements.\n",
    "\n",
    "For our question, we are going to assume that we are talking about simple phage and bacterial genes that don't have introns (after all, you have more phage and bacterial genes than human genes).\n",
    "\n",
    "Genes start with the codon `ATG` and end with one of the codons `TAA`, `TGA`, or `TAG`, and the codons need to be in-frame.\n",
    "\n",
    "<details>\n",
    "<summary>More assumptions!</summary>\n",
    "Of course, we are assuming that this is a phage or bacterial gene that doesn't have an intron, and that it doesn't start with `GTG` or `TTG`, and that the bacteria doesn't contain suppressor mutations that allow them to substitute amino acids in for the standard stop codons. In real life, we need to consider all those cases, but for now, we'll keep it simple!\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Qoz-W_TIz3QS"
   },
   "source": [
    "# `if` Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aTcPnZnF7S9-"
   },
   "source": [
    "* The `if` statement is how we express conditional logic in Python.\n",
    "* Virtually every programming language has this concept.\n",
    "* If statements define a condition and a sequence of statements to execute if the condition is `True`.\n",
    "\n",
    "Prototype...\n",
    "\n",
    "```\n",
    "if some_expression:    \n",
    "  do_this()\n",
    "  do_that()\n",
    "```\n",
    "\n",
    "If the condition is true, the indented statements are executed.\n",
    "Otherwise, the indented statements are skipped and program execution continues after the `if` statement.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 358,
     "status": "ok",
     "timestamp": 1719453918454,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "NzctV1Z6C3lk",
    "outputId": "0333dd63-50da-45f3-c2c1-8cf13274a9a3"
   },
   "outputs": [],
   "source": [
    "bases = \"AAAAATGCCCCC\"\n",
    "start = \"ATG\"\n",
    "if start in bases:\n",
    "    print(f\"The sequence {bases} has a start in it!\")\n",
    "    print(\"This is another line\")\n",
    "else:\n",
    "    print(f\"Sorry, no start in {bases}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s6BuZoxH7UcD"
   },
   "source": [
    "## Challenge\n",
    "\n",
    "In Python, we use indentation to associate a block of statements with a condition, for example...\n",
    "\n",
    "```\n",
    "print(\"1\")\n",
    "if some_condition:    \n",
    "  print(\"2\")    \n",
    "  print(\"3\")\n",
    "print(\"4\") # this line is NOT part of the if block\n",
    "```\n",
    "\n",
    "What does the output look like...\n",
    "* when the `some_condition` is True?\n",
    "* when the `some_condition` is False?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iIM5dHM87YwW"
   },
   "source": [
    "Here’s a slightly different example...\n",
    "```\n",
    "print(\"1\")\n",
    "if some_condition:    \n",
    "  print(\"2\")    \n",
    "print(\"3\")  # this line is NOT part of if block\n",
    "print(\"4\")  # this line is NOT part of if block\n",
    "```\n",
    "What’s different?\n",
    "What does the output look like...\n",
    "* when the `some_condition` is True?\n",
    "* when the `some_condition` is False?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BZrYYUiR8akX"
   },
   "source": [
    "## `if` Block Structure\n",
    "\n",
    "* In Python, `if` statements blocks are defined by indentation.\n",
    "* This idea of using indentation to delineate program structure is pervasive in Python and unique across programming languages.\n",
    "* For now, we're focusing on if statements but later we'll see how indentation is used to define other kinds of statement blocks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EY_CXBBE8iL0"
   },
   "source": [
    "### Block Stucture in Other Languages\n",
    "\n",
    "In other languages, explicit delineators are used. For example, in Java, C and C++ we would write:\n",
    "\n",
    "```\n",
    "if (bases contains \"ATG\") {\n",
    "    has_start = true;\n",
    "}\n",
    "```\n",
    "\n",
    "whereas, in Python we write:\n",
    "\n",
    "```\n",
    "if \"ATG\" in bases:\n",
    "    has_start = True\n",
    "```\n",
    "Indentation in Java/C/C++ is a helpful practice for program readability but it does not affect program functionality.\n",
    "In Python, indentation is not just a good idea - it's affects program logic!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QeVednm88pEn",
    "lines_to_next_cell": 2
   },
   "source": [
    "## Python's use of whitespace\n",
    "\n",
    "* Many people have strong opinions about this aspect of Python.\n",
    "* Don’t get hung up on this feature. Try it and see what you think after you've written a few Python programs.\n",
    "* Pitfalls:\n",
    "  * watch out for mismatched indentation within a block\n",
    "  * avoid mixing tabs and spaces in your code\n",
    "  * I prefer spaces because it's more explicit, and most programs will automatically insert spaces even if you press Tab\n",
    "\n",
    "**Pick _either_ tabs _or_ spaces _but_ be consistent.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nqHUiij_02RO"
   },
   "source": [
    "## `else` Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zkMiG5338ypF"
   },
   "source": [
    "Sometimes we want to specify an alternative to the `if` condition, which we do with an `else` statement, for example...\n",
    "\n",
    "```\n",
    "if <condition>:\n",
    "    <block1>\n",
    "else:\n",
    "    <block2>\n",
    "```\n",
    "\n",
    "* If the condition is true, block1 is executed.\n",
    "* if the condition is false, block2 is executed.\n",
    "\n",
    "The else cause is Python's way of saying \"otherwise...\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kVG18CiQ838a",
    "lines_to_next_cell": 2
   },
   "source": [
    "Just as `if` blocks are defined by indentation, `else` blocks are also defined by indentation.\n",
    "\n",
    "For example, this:\n",
    "\n",
    "```\n",
    "if <condition>:\n",
    "    <statement1>\n",
    "else:\n",
    "    <statement2>\n",
    "    <statement3>\n",
    "```\n",
    "is different from this:\n",
    "```\n",
    "if <condition>:\n",
    "    <statement1>\n",
    "else:\n",
    "    <statement2>\n",
    "<statement3>\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-uwGPHQt0vrJ"
   },
   "source": [
    "## `elif` Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Shf50kOm9GRl"
   },
   "source": [
    "Sometimes we need one or more intermediate conditions between the if and else parts, for example...\n",
    "\n",
    "`if A then do X, else if B then do Y, otherwise do Z`\n",
    "\n",
    "We use the `elif` statement to express this in Python...\n",
    "```\n",
    "if condition1:\n",
    "    do_thing_1()\n",
    "elif condition2:\n",
    "    do_thing_2()\n",
    "else:\n",
    "    do_thing_3()\n",
    "```\n",
    "* If `condition1` is true, `do_thing_1()` is executed.\n",
    "* Otherwise, if `condition2` is true, `do_thing_2()` is executed.\n",
    "* Otherwise, `do_thing_3()` is executed.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L9colMWL9HZw"
   },
   "source": [
    "* `elif` blocks are defined the same way as `if` and `else` blocks - using indentation.\n",
    "\n",
    "* It's good to have an if/elif for every condition of interest and not lump errors together with cases of interest.\n",
    "\n",
    "For example, if you care about values 1 and 2 and everything else is considered an error, this code:\n",
    "\n",
    "```\n",
    "if \"ATG\" in bases:      # deal with 1 here\n",
    "  starts_with_atg()\n",
    "elif \"TTG\" in bases:    # deal with 2 here\n",
    "  starts_with_ttg()\n",
    "else:           # deal with errors here\n",
    "  no_start_codon()\n",
    "```\n",
    "is better than this:\n",
    "```\n",
    "if \"ATG\" in bases:      # deal with 1 here\n",
    "  starts_with_atg()\n",
    "else:    # x must be 2 then, right? not necessarily!\n",
    "  starts_with_ttg()\n",
    "```\n",
    "The latter code hides errors by combining a valid case with error cases.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jJzPtT8z1Z6f"
   },
   "source": [
    "# For loops\n",
    "\n",
    "We have already actually used `for` loops when we were looking at dictionaries and lists, but just to reiterate ... if you want to iterate over a series of things, you can do so with a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 341,
     "status": "ok",
     "timestamp": 1719454266942,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "aIQwoZ_-XJVP",
    "lines_to_next_cell": 0,
    "outputId": "b6cf9eb7-aeb2-4501-f8b2-da9382ec51da"
   },
   "outputs": [],
   "source": [
    "genetic_code = { 'UUU' : 'Phe', 'UUA': 'Leu', 'CGA' : 'Arg', 'CGC' : 'Arg', 'CGG' : 'Arg', 'CGU' : 'Arg' }\n",
    "# loop through a dictionary (this iterates over the dictionary keys)\n",
    "for codon in genetic_code:\n",
    "    amino_acid = genetic_code[codon]\n",
    "    print(f\"The translation of {codon} is {amino_acid}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XteTHsEuXJVP"
   },
   "source": [
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V83AEjB7XJVP"
   },
   "source": [
    "\n",
    "## Advanced for loops\n",
    "\n",
    "`List iterators` are very useful, but you don't need to worry about them while you are starting out.\n",
    "\n",
    "<details>\n",
    "<summary>But you can learn more by expanding this region if you like</summary>\n",
    "\n",
    "Python also has a built in iterator that you sometimes see people use. This allows you to apply something to a list, and is called a `list iterator`.\n",
    "\n",
    "```\n",
    "genetic_code = { 'UUU' : 'Phe', 'UUA': 'Leu', 'CGA' : 'Arg', 'CGC' : 'Arg', 'CGG' : 'Arg', 'CGU' : 'Arg' }\n",
    "amino_acids = [genetic_code[base] for base in genetic_code]\n",
    "print(f\"All the amino acids are {amino_acids}\")\n",
    "```\n",
    "\n",
    "You can also use this to swap keys and values in a dictionary. Note that the order is not guaranteed, and so if your dictionary has two keys that point to the same value, you will loose one of them!\n",
    "\n",
    "```\n",
    "genetic_code = { 'UUU' : 'Phe', 'UUA': 'Leu', 'CGA' : 'Arg' }\n",
    "amino_acids = { value : key for key, value in genetic_code.items }\n",
    "print(f\"These are the codons for the amino acids: {amino_acids}\")\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iw7f76czaX4q"
   },
   "source": [
    "[Return to the lesson listing](#lessons)\n",
    "\n",
    "[Return to the top of the notebook](#top)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [
    {
     "file_id": "15KAyGvriQwRoXQa3t70jmi3XumKBxDRi",
     "timestamp": 1718237753735
    }
   ]
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}