Python_Course_MeInBio_PART1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"IMAGES_PYTHON_COURSE_2018/LOGO_MEINBIO_TRANSPARENT.png\" width=\"200\" height=\"200\" />\n",
    "# <center>Python course 2018\n",
    "### <center>MeInBio Training Group\n",
    "#### <center> by Florian Heyl & Francesco Ferrari \n",
    "Welcome to this introduction to Python. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PART 1 : TEXT MANIPULATION\n",
    "\n",
    "As biologists, we are often interested in analyzing and comparing sequence data (DNA/RNA/protein sequences). We can think of sequences as texts. In Python, we use the word \"STRING\" to refer to any text made of a set of characters ***between quotes***.\n",
    "\n",
    "An example of a string is:\n",
    "\n",
    "\"I am a string\" or \"The number 9 is cool\"\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- # Warming up \n",
    "\n",
    "The most basic thing you can do with a string is printing it onto the screen (standard output). To do that, we use the print() function; to run the code in the following lines, you must click upon the cell where the code is written and then press shift + enter. Alternatively, you can click the \"Run\" button that you can find in the toolbar at the top of the page "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise n° 1 (easy peasy): \n",
    "\n",
    "Print on the screen the string:\n",
    "\n",
    "\"I am going to love learning Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### insert your command in the space below\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# You can annotate your code using comments (this, in fact, is a comment to your code). \n",
    "# To write a comment, you must type a \"#\" followed by anything you want to write. \n",
    "# Alternatively, you can write comments using a triple single quote. For example: '''ciao belli'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may want to edit the output of your printing. For example, you may want to print \n",
    "\n",
    "    Hello\n",
    "    World!\n",
    "\n",
    "or \n",
    "\n",
    "    Hello    World!\n",
    "\n",
    "To do that you will need to include some ***printing special characters***. These will come in handy in your work.\n",
    "The two most important ones are: \n",
    "\n",
    "   - \\n : it breaks a line in two\n",
    "   - \\t : it inserts a tab space between what come before and after "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Edit printing output\n",
    "\n",
    "print(\"Hello\\nWorld!\")\n",
    "print('\\n')\n",
    "print(\"Hello\\tWorld!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise n° 2 (easy peasy)\n",
    "\n",
    "Print on standard output the lyrics of this famous song:\n",
    "\n",
    "    If everybody had an ocean\n",
    "    Across the U. S. A.\n",
    "    Then everybody'd be surfin'\n",
    "    Like Californi-a\n",
    "    You'd seem 'em wearing their baggies\n",
    "    Huarachi sandals too\n",
    "    A bushy bushy blonde hairdo\n",
    "    Surfin' U. S. A.\n",
    "    \n",
    "with the same line breaks, using **one** print command "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### insert your command in the space below\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- # Storing strings into variables\n",
    "\n",
    "We can take a string and assign a name to it using an equals sign – we call this a **variable**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here we create a variable called my_dna_sequence and we store a dna sequence into it \n",
    "\n",
    "my_dna_sequence = \"ATTCGATGGT\" \n",
    "\n",
    "# NB: the name that we give to a variable is completely arbitrary (e.g. we could as well have\n",
    "# used: banana = \"ATTCGATGGT\"). BUT, to make the code readable, it is important to use variable \n",
    "# names with some sort of meaning that is connected with what they store.\n",
    "# (e.g if we store the promoter sequence of GAPDH, you have better use something like:\n",
    "# GAPDH_prom_seq = \"ATTCGATGGT\"). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then refer to this sequence of DNA calling it by its name. You can think of a variable as a label that we stick onto a string (or a number or any other python object) and that we can use to refer to it.\n",
    "\n",
    "### Exercise n° 3 (easy peasy)\n",
    "\n",
    "Print to standard output the sequence \"ATTCGATGGT\" using its variable name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### insert your command in the space below\n",
    "\n",
    "\n",
    "### notice that when we use the variable name, we do not use any quotes! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the value of a variable as many times as we like.\n",
    "\n",
    "### Exercise n° 4 (easy peasy)\n",
    "\n",
    "Assign the new sequence \"GGGTCACCT\" to the variable my_dna_sequence and then print my_dna_sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### insert your command in the space below\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- # Tools for string manipulation\n",
    "\n",
    "### CONCATENATION\n",
    "\n",
    "We can stick together two or more strings using the + sign\n",
    "\n",
    "### Exercise n° 5 (easy)\n",
    "\n",
    "Create 2 variables and in each one of them store a string (of your choice). Then concatenate the two strings using the variable names you have created and the + sign. Eventually, print the result onto the screen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### insert your commands in the space below\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FINDING THE LENGTH OF A STRING & CONVERTING NUMBERS INTO STRINGS\n",
    "\n",
    "We can retrieve the length of a string using the function len()\n",
    "\n",
    "### Exercise n° 6 (easy)\n",
    "\n",
    "Store the output of Exercise 5 in a variable. Then print the length of the string that you have just stored inside the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### insert your commands in the space below\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the output of the len() function is a number. Python treats strings and numbers differently. For example, you cannot concatenate strings and numbers. You can check this by running the following code "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fav_DNA = 'ATTCCCATGGG'\n",
    "len_fav_DNA = len(my_fav_DNA)\n",
    "print(\"The length of \" + my_fav_DNA + \" is \" + len_fav_DNA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, what if you have a DNA sequence and you have just calculated its length using the len() function and you want to print the following message: \"The length of my favourite DNA sequence is 10\" ? There are three ways to do go about it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. You can print strings and numbers without concatenating them, but separating them with a coma \n",
    "# inside the same print() call, \n",
    "\n",
    "print(\"The length of \" + my_fav_DNA + \" is\", len_fav_DNA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. You can convert the number into a string using the str() function\n",
    "\n",
    "print(\"The length of \" + my_fav_DNA + \" is \" + str(len_fav_DNA))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. (Advanced - optional) You can format the string using place-holders\n",
    "\n",
    "print(\"The length of {} is {}\".format(my_fav_DNA, len_fav_DNA))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise n° 7 (easy)\n",
    "\n",
    "Create three DNA sequences (at random) and concatenate them. Then, print a sentence that explicitates the original length of each individual sequence and the length of the concatenated one.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### insert your commands in the space below\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CHANGING CASES\n",
    "\n",
    "Two usefull methods allow you to convert a string to lower or upper cases. Here under is how they work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "low_string = \"hi, my name is francesco\"\n",
    "print(low_string.upper())\n",
    "\n",
    "up_string = \"HI, MY NAME IS FLORIAN\"\n",
    "print(up_string.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### REPLACEMENT\n",
    "\n",
    "The replace() method allows you to **replace** each occurrence of a substring with a different substring. Let's make it clear with an example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# suppose we have a protein sequence and we want to replace each valine with a tyrosine:\n",
    "\n",
    "protein = \"vlspadktnvl\"\n",
    "print(protein.replace(\"v\", \"y\"))\n",
    "# here, the first letter inside the replace parenthesis (\"v\") indicates the substring you want \n",
    "# to substitute, while the second (\"y\") indicates the substring you want to substitute it with. \n",
    "\n",
    "# Methods can be used sequencially. So, if you want to make a replacement and then transform \n",
    "# the string to upper-cases, you can write:\n",
    "print(protein.replace(\"v\",\"y\").upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXTRACTING PART OF A STRING\n",
    "\n",
    "We call a part of a string a **substring**. What if we want to isolate a substring out of a longer string? For example, consider the string \"Oh my Gosh!\", and say we want to isolate the word \"Gosh\". To do that, we have to count in which position is starts and end the word \"Gosh\". **BUT, in Python WE START COUNTIN FROM 0 (NOT FROM 1)!** \n",
    "\n",
    "So, in our case, the word we are interested in starts at position 6 (it is the 7th letter of our string, but **we count from 0**). The sintax that we have to use is the following: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exclamation = \"Oh my Gosh!\"\n",
    "print(exclamation[6:10])\n",
    "# this is to say: from the variable exclamation, we want to extract the 6th element \n",
    "# (included) up to the 10th element (excluded) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please notice one important thing: the word \"Gosh\" starts at position 6 but ends at position 9. When we subset a string with square brakets, the first number before the columns is the index of the first letter that will be included in the output, while the second is the index of the first letter that will be excluded from the output. This is why, instead of writing print(exclamation[6:9]) we wrote print(exclamation[6:10]) \n",
    "\n",
    "In case we want to subset a string from its beginning or up to its end, we can omit the first or the last number respectively. For example, if we want a substring starting from the beginning of a string up to the n-th letter we will write: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(exclamation[:5])\n",
    "# this is to say: from the variable exclamation, we want to extract from the beginning  \n",
    "# up to the 5th element (excluded) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, if we want a substring from the n-th position up to the end of the string we will write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(exclamation[3:])\n",
    "# this is to say: from the variable exclamation, we want to extract from the beginning  \n",
    "# up to the 5th element (excluded) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Last but not least, letters of a string can be indexed also backwards. Let's say we want to extract the last two letters of a string. We will write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(exclamation[-2:])\n",
    "# gets the last two letters\n",
    "\n",
    "print(exclamation[-1])\n",
    "# gets the last letter\n",
    "\n",
    "print(exclamation[-5:-1])\n",
    "# gets the substring \"Gosh\"  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To summarize, here is an image that shows the two alternative ways we can use to refer to each element of a string:\n",
    "\n",
    "<img src=\"IMAGES_PYTHON_COURSE_2018/indexing_string.png\" width=\"900\" height=\"400\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise n° 8 (easy)\n",
    "\n",
    "In the following cell you will give you a string. You have to extract the 3 substring that we specify using forward/backward indexing.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Cell type: HepG2\"\n",
    "\n",
    "# 1: ISOLATE THE SUBSTRING: \"Cell type:\" USING FORWARD INDEXING\n",
    "\n",
    "\n",
    "\n",
    "# 2: ISOLATE THE SUBSTRING: \"HepG2\" UNSING FORWARD INDEXING\n",
    "\n",
    "\n",
    "\n",
    "# 3: ISOLATE THE SUBSTRING: \"HepG2\" USING BACKWARD INDEXING\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SPLIT and JOIN\n",
    "\n",
    "In the next notebook, you will be introduced to lists. For now, let it suffice to say that a list is an ordered collection of python objects. If we have a string, we can split that string in its components (its words) and have them stored into a list. More than that, we can decide which character should be used to split our string. \n",
    "\n",
    "This is how we do that in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \"Today I am having the time of my life\"\n",
    "\n",
    "print(string.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_underscore = \"I_have_never_had_so_much_fun_ever_in_my_life\"\n",
    "\n",
    "print(\"Here I am splitting my string at every occurrence of the underscore sign:\")\n",
    "print(string_underscore.split(\"_\"))\n",
    "print(\"\\nHere I am splitting my string at every occurrence of the letter 'v':\")\n",
    "print(string_underscore.split(\"v\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eventually, we can also go the other way around. If we have a list, we can make a string out of that list by using the function **join()**.  \n",
    "\n",
    "Here is how we do it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [\"P\",\"y\",\"t\",\"h\",\"o\",\"n\"]\n",
    "\n",
    "print(\"\".join(my_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list_2 = [\"Python\",\"is\",\"just\",\"amazing\"]\n",
    "\n",
    "print(\" \".join(my_list_2))\n",
    "print(\"\\t\".join(my_list_2))\n",
    "print(\"*\".join(my_list_2))\n",
    "print(\"_\".join(my_list_2))\n",
    "\n",
    "# Do you understand how it works?"
   ]
  }
 ],
 "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
}