Python_Course_MeInBio_PART5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"IMAGES_PYTHON_COURSE_2018/LOGO_MEINBIO_TRANSPARENT.png\" width=\"200\" height=\"200\" />\n",
    "\n",
    "# <center>Python course 2018\n",
    "### <center>MeInBio Training Group \n",
    "#### <center> by Florian Heyl & Francesco Ferrari "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PART 5: CONDITIONAL STATEMENTS\n",
    "\n",
    "An interesting piece of program is one that can evaluate if certain conditions are met and act accordingly. For example, imagine we have a DNA sequence and we want to print it to the screen if the sequence is longer than 300 bp. Or imagine we have a count table (from an RNA-Seq experiment) with the number of reads mapped to each gene and we want our program to discard a gene if that gene has less that 10 reads mapped to it. \n",
    "\n",
    "Whenever we want our program to verify if a condition is met, we use a conditional statement. Let's have a look at what are conditions and how conditional statements work in Python. \n",
    "\n",
    "### What is a condition? \n",
    "\n",
    "A condition is simply a bit of code that can produce a true or false answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# examples of conditions\n",
    "\n",
    "print(len('ATCCGTA') > 2)\n",
    "print(20 == 30) ### PLEASE NOTICE THAT WE USE \"==\" AND NOT \"=\" TO TEST IF TWO ITEMS ARE THE SAME\n",
    "print(\"I Love Pizza\".startswith('I'))\n",
    "print(\"I Also Love Carbonara\".endswith(\"y\"))\n",
    "print(\"apple\" in [\"banana\",\"orange\",\"cherry\"])\n",
    "print(\"Anakin\" != \"Luke\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- # If else Statements\n",
    "\n",
    "We have just seen how to build some conditions and have our code to output True or False if the condition is met or not met respectively. Now, we are ready to make our program take decisions and act according to a condition's outcome.\n",
    "\n",
    "The simplest kind of conditional statement is an \"if statement\". In Python, the syntax for if statements in very easy:\n",
    "\n",
    "We write the word \"if\", followed by a condition, and end the first line with a colon. There follows a block of indented lines of code (the body of the if statement), which will only be executed if the condition is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example of if statement 1 (easy)\n",
    "\n",
    "my_sequence = \"AAAATCCCCGTACT\"\n",
    "if len(my_sequence) > 4:\n",
    "    print(\"my sequence is long\".upper())\n",
    "else:\n",
    "    print(\"my sequence is short\".lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise n° 1 (medium): \n",
    "\n",
    "Given a list of tuples of the form (chr, gene_name), identify all genes present in the X chromosome and save them to a text file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import os\n",
    "sys.path.append(os.path.abspath(\"./BOOK_and_other_resources/\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import python_course_functions as pcf\n",
    "gene_list = pcf.loadGeneList(\"./BOOK_and_other_resources/gene_list.txt\")\n",
    "\n",
    "print(\"You are working with {} genes\".format(len(gene_list)))\n",
    "\n",
    "gene_list[0:10] # to see the structure of your data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### insert your commands in the space below\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ##  Elif statements\n",
    "\n",
    "If we have more than 2 possible branches, instead of using else, we use elif. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example of elif statement\n",
    "my_fav_fruit=[\"banana\", \"apple\", \"cherry\", \"kiwi\", \"pear\", \"rasberry\", \"blueberry\", \"peach\", \"ca\"]\n",
    "\n",
    "for fruit in my_fav_fruit:\n",
    "    if len(fruit) == 4:\n",
    "        print(\"'{}' has 4 letters\\n\".format(fruit))\n",
    "    elif len(fruit) == 5:\n",
    "        print(\"'{}' has 5 letters\\n\".format(fruit))\n",
    "    elif len(fruit) > 5:\n",
    "        print(\"'{}' is a very long word\\n\".format(fruit))\n",
    "    else:\n",
    "        print(\"'{}' is a very short word\\n\".format(fruit))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise n° 2 (medium): \n",
    "\n",
    "Using the same list of tuples of the form (chr, gene_name) from exercise 1, write to separate files all genes found on chromosome 1, chromosome 4, chromosome 11 and chromosome Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### insert your commands in the space below\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- # Combining Conditions with and / or"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to express conditions made up of several parts. For example, given a list of accession IDs, print all IDs that start with \"a\"/\"A\" and end with \"z/\"Z\". To do that, we use the operator \"and\". The combined \"if\" condition will return a True if all conditions are satisfied, False otherwise. \n",
    "\n",
    "Alternatively, we can write disjunctive conditions using the \"or\" logical operator. In this case, the combined \"if\" condition will return a True if at least one of the conditions are satisfied, False if all condition are not satisfied.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_ID = [\"ID_a132i398zzz\",\n",
    "           \"ID_b34573y4jnj\",\n",
    "           \"ID_S45u92s8fgz\",\n",
    "           \"ID_Afkj3ehrdZZ\",\n",
    "           \"ID_Askdsa3s4nz\",\n",
    "           \"ID_EFGJNG24OIN\",\n",
    "           \"ID_234oitfunkj\",\n",
    "           \"ID_ASOI0934U5Z\",\n",
    "           \"ID_ewowrit13ir\"]\n",
    "\n",
    "print(\"IDs starting with 'a' AND ending with 'z':\")\n",
    "for i in list_ID:\n",
    "    id_seq = i.split(\"_\")[1]\n",
    "    if id_seq[0].lower() == \"a\" and id_seq[-1].lower() == \"z\":\n",
    "        print(i)\n",
    "print(\"\\n\")     \n",
    "print(\"IDs starting with 'e' OR ending with 'j':\")\n",
    "for i in list_ID:\n",
    "    id_seq = i.split(\"_\")[1]\n",
    "    if id_seq[0].lower() == \"e\" or id_seq[-1].lower() == \"j\":\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise n° 3 (medium):\n",
    "\n",
    "A) Using the gene list from exercise 1, count how many genes are found in chromosome 1 and have a ID that ends with 1. \n",
    "\n",
    "B) Using the same list, count how many genes are found in chromosome 2 and 4 which have and ID whose number after the dot is either a 3 or a 7. (PAY ATTENTION! THIS IS DIFFERENT FROM THE CONDITION OF 3A).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### insert your commands in the space below\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expected Outcome:\n",
    "\n",
    "\n",
    "3A): 2092          \n",
    "3B): 559"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- # Boolean functions and conditional statements\n",
    "\n",
    "Sometime, you may need to check if a complex condition (that means, a condition that cannot be expressed with the standard tools \"==\", \">\", \"<\", \"endswith\", \"startswith\", etc.) holds true and have your script react according to the outcome.\n",
    "\n",
    "To do that, we must write our own function that returns a True if the condition we want to test is met, and False otherwise. \n",
    "\n",
    "For example:\n",
    "  \n",
    "Say that you want to check if a sequence is AT-rich. If the sequence is AT-rich, then you print it to the screen with the corresponding percentage. You also want to collect all not AT-rich regions in a list, and print it to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_AT_rich(sequence):\n",
    "    sequence = sequence.lower()  # sequence is made of lower characters to avoid mismatches due to capitalization\n",
    "    a = sequence.count(\"a\") # count how many \"a\" are in the sequence\n",
    "    t = sequence.count(\"t\") # count how many \"t\" are in the sequence\n",
    "    fr_at = (a+t)/len(sequence) # compute the fraction of at present in the sequence\n",
    "    if fr_at >= 0.65:    # if the fraction is greater or equal 0.65 (65%) ...\n",
    "        return (True, fr_at) # return a tuple where the first element is a True (boolean), and the second is the at fraction\n",
    "    else:                   # otherwise\n",
    "        return (False, fr_at)  # return a tuple where the first element is a False (boolean), and the second is the at fraction \n",
    "    \n",
    "sequences = [\"ATTTGTCCAAAGTATATAT\",\n",
    "             \"GGGCGAGGCGTTGCGAGGG\",\n",
    "             \"GGCGAAAAAAATTTTTTTT\",\n",
    "             \"AAATATATATATATATATA\",\n",
    "             \"GGATTATCCTGGATATATAT\",\n",
    "             \"TTTTTTTTTTTAAAAAAAAA\",\n",
    "             \"GGGTTTTTATATATTTAAAT\",\n",
    "             \"GGGTGGGCGCGCGCGAGGGG\"]\n",
    "\n",
    "not_AT_rich = []\n",
    "for sequence in sequences:\n",
    "    if is_AT_rich(sequence)[0]:\n",
    "        print(\"{} is composed for the {}% of AT\\n\".format(sequence, round(is_AT_rich(sequence)[1]*100,1) ))\n",
    "    else:\n",
    "        not_AT_rich.append(sequence)\n",
    "print(\"{} sequence were not AT-rich:{}\".format(len(not_AT_rich), not_AT_rich))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise n° 4 (difficult):\n",
    "\n",
    "write a function that verifies whether a in a sequence there are at least 4 CpG (a C immediately followed by a G, i.e. \"CG\") and return a True if so, False otherwise. \n",
    "\n",
    "Then, given a list of sequence, print to screen those sequences that have at least 4 CpG in them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_sequences = [\"CGGGGAGTCGAAATTGCTA\",\n",
    "                 \"ATTCGCGCGCGATAATTCG\",\n",
    "                 \"TTTCGGCCGCGATTTACGG\",\n",
    "                 \"TTAATTCGGGATCGCGAAT\"]\n",
    "\n",
    "### insert your commands in the space below\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expected Outcome:\n",
    "\n",
    "ATTCGCGCGCGATAATTCG\n",
    "\n",
    "TTTCGGCCGCGATTTACGG"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:anaconda3]",
   "language": "python",
   "name": "conda-env-anaconda3-py"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}