Python_Course_MeInBio_PART2.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 \n",
    "<center> Welcome to this introduction to Python. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PART 2 : LISTS, LOOPS AND BRANCHES\n",
    "\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1: Lists\n",
    "\n",
    "List are some sort of array in python. Lets dive right into it to get a feeling of what lists are."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "proteins = [\"DDX3X\", \"AUH\", \"GTF2F1\", \"EWSR1\"]\n",
    "replicates = [2,3,2,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we created two lists, one holding proteins we studied and one holding how many biological replicates we have done for each protein. \n",
    "\n",
    "Lets say we want just the first protein of our list we simply do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(proteins[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**!! Lists allways start at 0 in python!!**\n",
    "This is not allways the case. Most languages do it that way. But some crazy people think that its more intuite to start at 1 like in **R**. So allways check before you start coding. \n",
    "\n",
    "To test how long a list is you simply do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(proteins))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we get the anticapted length of four proteins. \n",
    "\n",
    "<img src=\"IMAGES_PYTHON_COURSE_2018/question-mark.png\" width=\"24\" height=\"24\" style=\"float: left;\"/> What is then the last index of the list **proteins**? \n",
    "\n",
    "#### TASK \n",
    "\n",
    "Check your assumption in the field below. What do you get if you go beyond the lists capacity?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### put your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is very kind in that sense, telling you when you are out of bounds. Other languages like **R** or **C++** sometimes give you no error and garbage as an output. So allways be careful in other languages. \n",
    "\n",
    "Python has a very intuitive way to get intervals from lists. Let's say that I want the first two proteins out of my list. then I do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(proteins[0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The snythax can be intepreted as including the index 0 and excluding the index 2. So we go from 0 to 1.\n",
    "\n",
    "### TASK \n",
    "\n",
    "Give two possible ways to print the full content of **proteins**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### put your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what if I don't want the first two proteins, and I want instead the last two? Python has an intuitve way to deal with it, without making the synthax too complicated. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(proteins[-2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maybe you already see what this resembles. The synthax is the same as for stings (how convienient!) because strings are nothing else than a list of character. So the word \"hello\" is just a list holding [\"h\", \"e\", \"l\", \"l\", \"o\"]. \n",
    "\n",
    "So the next thing that comes to our mind might be to add a new element to an existing list. Let's say that we have done a new experiment for the protein \"UPF1\". Then, we simply add the protein to the list by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "proteins.append(\"UPF1\")\n",
    "print(proteins)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function **append()** takes and object of different type and adds it to list. \n",
    "\n",
    "### TASK \n",
    "\n",
    "The experiment I have done for UPF1 had **5 replicates**. Add the number to the list **replicates**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### put your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, so far so good. But what if I made a change and my first protein DDX3X had actually 3 instead of 2 replicates? Like we have learnd, we can simply get the value an change it by doing this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(replicates[0])\n",
    "replicates[0] = 3\n",
    "print(replicates[0])\n",
    "print(replicates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also combine list. Let's say we already had a protein list and want to combine our new one with the old one. Then we do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "proteins_old = ['DDX3X', 'SRSF1', 'YWHAG']\n",
    "print(proteins)\n",
    "proteins_new = proteins + proteins_old\n",
    "print(proteins_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ups, I made a mistake an the list **proteins** contains now two entries of \"DDX3X\".\n",
    "\n",
    "### TASK\n",
    "\n",
    "Find a way to remove the second entry of DDX3X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### put your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2: Loops\n",
    "\n",
    "Python has various type of loops. The most frequently used loop in every programming language is the **for loop**. For loops have different synthax in every language, so you have to check outside of python how you can use them. Even in python the **for loop** can vary based on the object you applying it to. But lets get a hands on to see what they are doing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "peaks_for_DDX3X = [\"peak\", \"peak\", \"peak\", \"peak\"]\n",
    "reads_in_peaks = [24, 3, 10, 16]\n",
    "reads_in_control = [23, 3, 5, 12]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets say I ran a peak calling algorithm and I want the number of reads for each peaks the algorithm has called, then I do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in reads_in_peaks:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple as that. What the for loop is doing here is the definition of an object that has the same type as each individual object inside the list **reads_in_peaks**. Another way to do the **for-loop** is by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0, len(reads_in_peaks)):\n",
    "    print(reads_in_peaks[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output is the same but **i** is different now. We defined an integer that goes from 0 to the end of **reads_in_peaks**. So, in order to retrieve the element, we have to put the varaible **i** inside of our list **reads_in_peaks** like we have done it in the previous exercise.\n",
    "\n",
    "### TASK\n",
    "\n",
    "As you may have seen already, the list **peaks_for_DDX3X** contains four instances of the word \"peak\". However to dinstinguish them I want to rename them and give them a number based on their position. Use the knowledge you obtained so far and redefine the elements in the list **peaks_for_DDX3X**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### put your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets imagine this peak list are four distinctive peaks from one gene. Your collaborator asks you to find one specific and significant motif. So you first eyeball the number of reads in peaks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(reads_in_peaks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With that you find that the first peak is most likely a very significant target. However, as a good scientist you have done also a negative control. The list **reads_in_control** describes the analysed reads that fall in the same peak regions your peak calling algorithm has found. \n",
    "\n",
    "### TASK \n",
    "\n",
    "Find the most significant peak by calculating a simple foldchange with the help of a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### put your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TASK\n",
    "\n",
    "You have done two replicates for your experiment. Find me the most significant peak. We assume that the data is normalized. \n",
    "\n",
    "HINT: find also a way to express the robustness for the peaks. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "random.seed(123)\n",
    "\n",
    "reads_in_peaks_rep1 = [random.randint(1, 100) for p in range(0, 20)]\n",
    "reads_in_peaks_rep2 = [random.randint(1, 100) for p in range(0, 20)]\n",
    "reads_in_control = [random.randint(1, 100) for p in range(0, 20)]\n",
    "\n",
    "### put your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 3: Loops with Lists\n",
    "\n",
    "Python has a neat little way to do loops with list in one line. For example the for loop we used to iterate through the list **peaks_for_DDX3X** can be achieved in a different way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['peak_0', 'peak_1', 'peak_2', 'peak_3']\n"
     ]
    }
   ],
   "source": [
    "peaks_for_DDX3X = [\"peak\", \"peak\", \"peak\", \"peak\"]\n",
    "peaks_for_DDX3X = [peaks_for_DDX3X[i] + \"_\" + str(i) for i in range(0, len(peaks_for_DDX3X))]\n",
    "print(peaks_for_DDX3X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first part of the second line **peaks_for_DDX3X[i] + \"_\" + str(i)** is simply a concatenation of our peak name.\n",
    "The rest is what we already learned from the for loops.\n",
    "\n",
    "### TASK\n",
    "\n",
    "Try and implement the calculation of the foldchange in one line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "reads_in_peaks = [24, 3, 10, 16]\n",
    "reads_in_control = [23, 3, 5, 12]\n",
    "\n",
    "### put your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 4: While Loops\n",
    "\n",
    "**For** loops are not the only types. Every programming language including python has **while** loops. In contrast to **for** loops, **while** loops interate until a certain condition is met. Lets see what this means:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 6:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the loop is executed until the iterator **i** is equal to 6. Now you might ask, what is actually the big difference between a **for** and a **while** loop? \n",
    "\n",
    "The **for** statement iterates through a collection or iterable object or generator function.\n",
    "The **while** statement simply loops until a condition is False.\n",
    "\n",
    "Now you might ask. When do I use **for** and when do I use **while** loops?\n",
    "\n",
    "This really depends on your own demands and your own thinking. Be careful in other languages. Sometimes while and for loops behave more differently than you might think. \n",
    "\n",
    "### TASK\n",
    "\n",
    "Implement a **for** loop for the **while** loop in this exercise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "### put your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 5: Branches\n",
    "\n",
    "You might haven't realised it, but you already used branches. Branches are simple conditions you ask during the code. Like in the **while** loop, every iteration asked if our iterator **i** is smaller than 6 and if not then the **while** loop would stop. So let's see how we can use branches in python outside of loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes1\n",
      "yes2\n",
      "yes4\n"
     ]
    }
   ],
   "source": [
    "peaks_for_DDX3X = [\"peak1\", \"peak2\", \"peak3\", \"peak4\"]\n",
    "reads_in_peaks = [24, 3, 10, 16]\n",
    "reads_in_control = [23, 3, 5, 12]\n",
    "\n",
    "if(peaks_for_DDX3X[0] == \"peak1\"):\n",
    "    print(\"yes1\")\n",
    "if(reads_in_peaks[0] > 20):\n",
    "    print(\"yes2\")\n",
    "if(reads_in_peaks[0] < 20):\n",
    "    print(\"yes3\")\n",
    "if(123 > 20):\n",
    "    print(\"yes4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see we simply ask logical **yes/no** questions with the **if** statement. To compare something with something else you use the logical operator: **> < >= <= == !=**. <br/>\n",
    "\n",
    "<img src=\"IMAGES_PYTHON_COURSE_2018/question-mark.png\" width=\"24\" height=\"24\" style=\"float: left;\"/>\n",
    "Keep in mind, in every language you always check if something should be equal to something else with the oprator **==**. Do you have an idea why? <br/> \n",
    "\n",
    "<img src=\"IMAGES_PYTHON_COURSE_2018/question-mark.png\" width=\"24\" height=\"24\" style=\"float: left;\"/>\n",
    "What does the operator **!=** mean?\n",
    "\n",
    "### TASK \n",
    "\n",
    "Amend the **for** loop in exercise 2 where we calculated the foldchange. Check every time with an **if** statement if the foldchange is **bigger or equal than 2**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### put your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cool thing: you can also chain conditions in one **if** statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes1\n",
      "yes3\n"
     ]
    }
   ],
   "source": [
    "if(reads_in_peaks[0] > 20 and peaks_for_DDX3X[0] == \"peak1\"):\n",
    "    print(\"yes1\")\n",
    "if(reads_in_peaks[0] > 20 and peaks_for_DDX3X[0] == \"peak2\"):\n",
    "    print(\"yes2\")\n",
    "if(reads_in_peaks[0] > 20 or peaks_for_DDX3X[0] == \"peak2\"):\n",
    "    print(\"yes3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"IMAGES_PYTHON_COURSE_2018/question-mark.png\" width=\"24\" height=\"24\" style=\"float: left;\"/> The logical operators **and/or** chain conditions in an **if** statement together. What is the difference between **and** and **or**?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "peaks_for_DDX3X = [\"peak1\", \"peak2\", \"peak3\", \"peak4\"]\n",
    "reads_in_peaks = [24, 3, 10, 16]\n",
    "reads_in_control = [23, 1, 5, 8]\n",
    "p_value = [0.001, 0.0013, 0.0015, 0.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TASK\n",
    "\n",
    "Amend the **for** loop from our previous task **using the new data**. Check if the foldchange is **bigger or equal than 2** and simultanously check if the p-value is **smaller or equal than 0.05**. Print the name of the peak if the condition is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "### put your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's add something new to our **if** statment. Sometimes you need to do something when the condition inside the **if** statment is not met. For that reason we have the **else** statement. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no\n"
     ]
    }
   ],
   "source": [
    "if(peaks_for_DDX3X[0] == \"peak2\"):\n",
    "    print(\"yes\")\n",
    "else:\n",
    "    print(\"no\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see, it is quite intutive. If the condition in **if** is false then the **else** statement is executed. \n",
    "\n",
    "### TASK\n",
    "\n",
    "Amend the **for** loop from our previous task. Add an **else** statment to the **if** condition. Print the foldchange and the p-value, if the condition of the **if** statement is false. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "### put your code here"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}