lab5_exercises_ANSWERS_v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming Bootcamp 2016\n",
    "# Lesson 5 Exercises -- ANSWERS\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 1. Guess the output: dictionary practice (1pt)\n",
    "\n",
    "For the following blocks of code, first try to guess what the output will be, and then run the code yourself. Points will be given for filling in the guesses; guessing wrong won't be penalized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# run this cell first!\n",
    "fruits = {\"apple\":\"red\", \"banana\":\"yellow\", \"grape\":\"purple\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yellow\n"
     ]
    }
   ],
   "source": [
    "print fruits[\"banana\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red\n"
     ]
    }
   ],
   "source": [
    "query = \"apple\"\n",
    "print fruits[query]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-7686ce77805a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mprint\u001b[0m \u001b[0mfruits\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 0"
     ]
    }
   ],
   "source": [
    "print fruits[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> There's no concept of \"first element\" in a dictionary, since it's unordered. (Of course, if you happened to have a key in your dictionary that was literally 0, this code would work.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['grape', 'apple', 'banana']\n"
     ]
    }
   ],
   "source": [
    "print fruits.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['purple', 'red', 'yellow']\n"
     ]
    }
   ],
   "source": [
    "print fruits.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "purple\n",
      "red\n",
      "yellow\n"
     ]
    }
   ],
   "source": [
    "for key in fruits:\n",
    "    print fruits[key]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'grape': 'purple', 'apple': 'red'}\n"
     ]
    }
   ],
   "source": [
    "del fruits[\"banana\"]\n",
    "print fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'pear'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-55a4a5628a2c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mprint\u001b[0m \u001b[0mfruits\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"pear\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'pear'"
     ]
    }
   ],
   "source": [
    "print fruits[\"pear\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "green\n"
     ]
    }
   ],
   "source": [
    "fruits[\"pear\"] = \"green\"\n",
    "print fruits[\"pear\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red or green\n"
     ]
    }
   ],
   "source": [
    "fruits[\"apple\"] = fruits[\"apple\"] + \" or green\"\n",
    "print fruits[\"apple\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Since fruits[\"apple\"] contains a string, we can concatenate to that string just like we would normally. And if instead the value was a number, we could add to it. Basically, you can treat the \"dict[key]\" as a variable that holds whatever the value is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 2. On your own: using dictionaries (6pts)\n",
    "\n",
    "Using the info in the table below, write code to accomplish the following tasks.\n",
    "\n",
    "|    Name   | Favorite Food |\n",
    "|:---------:|:-------------:|\n",
    "|  Wilfred  |     Steak     |\n",
    "|  Manfred  |  French fries |\n",
    "| Wadsworth |   Spaghetti   |\n",
    "|   Jeeves  |   Ice cream   |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** Create a dictionary based on the data above, where each person's name is a key, and their favorite foods are the values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Manfred': 'French fries', 'Wadsworth': 'Spaghetti', 'Wilfred': 'Steak', 'Jeeves': 'Ice cream'}\n"
     ]
    }
   ],
   "source": [
    "favFoods = {\"Wilfred\":\"Steak\", \"Manfred\":\"French fries\", \"Wadsworth\":\"Spaghetti\", \"Jeeves\":\"Ice cream\"}\n",
    "print favFoods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** Using a `for` loop, go through the dictionary you created above and print each name and food combination in the format:\n",
    "\n",
    "    <NAME>'s favorite food is <FOOD>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manfred's favorite food is French fries\n",
      "Wadsworth's favorite food is Spaghetti\n",
      "Wilfred's favorite food is Steak\n",
      "Jeeves's favorite food is Ice cream\n"
     ]
    }
   ],
   "source": [
    "for name in favFoods:\n",
    "    print name + \"'s favorite food is \" + favFoods[name]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(C)** (1) Change the dictionary so that Wilfred's favorite food is Pizza. (2) Add a new entry for Mitsworth, whose favorite food is Tuna. \n",
    "\n",
    "Do not recreate the whole dictionary while doing these things. Edit the dictionary you created in (A) using the syntax described in the lecture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Manfred': 'French fries', 'Wadsworth': 'Spaghetti', 'Wilfred': 'Pizza', 'Mitsworth': 'Tuna', 'Jeeves': 'Ice cream'}\n"
     ]
    }
   ],
   "source": [
    "favFoods[\"Wilfred\"] = \"Pizza\"\n",
    "favFoods[\"Mitsworth\"] = \"Tuna\"\n",
    "print favFoods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(D)** Prompt the user to input a name. Check if the name they entered is a valid key in the dictionary using an `if` statement. If the name is in the dictionary, print out the corresponding favorite food. If not, print a message saying \"That name is not in our database\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a name: Jimothy\n",
      "That name is not in our database\n"
     ]
    }
   ],
   "source": [
    "name = raw_input(\"Enter a name: \")\n",
    "if name in favFoods:\n",
    "    print favFoods[name]\n",
    "else:\n",
    "    print \"That name is not in our database\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(E)** Print just the names in the dictionary in alphabetical order. Use the sorting example from the slides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jeeves\n",
      "Manfred\n",
      "Mitsworth\n",
      "Wadsworth\n",
      "Wilfred\n"
     ]
    }
   ],
   "source": [
    "for name in sorted(favFoods):\n",
    "    print name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(F)** Print just the names in sorted order based on their favorite food. Use the value-sorting example from the slides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manfred\n",
      "Jeeves\n",
      "Wilfred\n",
      "Wadsworth\n",
      "Mitsworth\n"
     ]
    }
   ],
   "source": [
    "for name in sorted(favFoods, key=favFoods.get):\n",
    "    print name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 3. File writing (3pts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** Write code that prints \"Hello, world\" to a file called `hello.txt`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "outs = open(\"hello.txt\", 'w')\n",
    "outs.write(\"Hello, world\")\n",
    "outs.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** Write code that prints the following text to a file called `meow.txt`. It must be formatted exactly as it here (you will need to use \\n and \\t):\n",
    "```\n",
    "Dear Mitsworth,\n",
    "    \n",
    "    Meow, meow meow meow.\n",
    "    \n",
    "Sincerely,\n",
    "A friend\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "outs = open(\"meow.txt\", 'w')\n",
    "outs.write(\"Dear Mitsworth,\\n\\n\\tMeow, meow meow meow.\\n\\nSincerely,\\nA friend\")\n",
    "outs.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(C)** Write code that reads in the gene IDs from `genes.txt` and prints the **unique** gene IDs to a **new file** called `genes_unique.txt`. (You can re-use your code or the answer sheet from lab4 for getting the unique IDs.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "inFile = \"genes.txt\"\n",
    "outFile = \"genes_unique.txt\"\n",
    "unique = []\n",
    "\n",
    "ins = open(inFile, 'r')\n",
    "outs = open(outFile, 'w')\n",
    "\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\n')\n",
    "    if line not in unique:\n",
    "        outs.write(line + \"\\n\")\n",
    "        unique.append(line)\n",
    "        \n",
    "outs.close()\n",
    "ins.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 4. The \"many counters\" problem (4pts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** Write code that reads a file of sequences and tallies how many sequences there are of each length. Use `sequences3.txt` as input. \n",
    "\n",
    "*Hint: you can use a dictionary to keep track of all the tallies. For example:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# hint code:\n",
    "\n",
    "tallyDict = {}\n",
    "seq = \"ATGCTGATCGATATA\"\n",
    "length = len(seq)\n",
    "\n",
    "if length not in tallyDict:\n",
    "    tallyDict[length] = 1  #initialize to 1 if this is the first occurrence of the length...\n",
    "else:\n",
    "    tallyDict[length] = tallyDict[length] + 1   #...otherwise just increment the count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "inFile = \"sequences3.txt\"\n",
    "lenDict = {}\n",
    "ins = open(inFile, 'r')\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\n') #important to do here, since '\\n' counts as a character and thus increases the length of the sequence by 1\n",
    "    seqLen = len(line)\n",
    "    if seqLen not in lenDict:\n",
    "        lenDict[seqLen] = 1\n",
    "    else:\n",
    "        lenDict[seqLen] = lenDict[seqLen] + 1\n",
    "ins.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** Using the tally dictionary you created above, figure out which sequence length was the most common, and print it to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27 : 4\n",
      "30 : 2\n",
      "33 : 3\n",
      "36 : 4\n",
      "39 : 4\n",
      "42 : 6\n",
      "45 : 5\n",
      "48 : 3\n",
      "51 : 7\n",
      "54 : 5\n",
      "57 : 3\n",
      "60 : 4\n",
      "63 : 3\n",
      "66 : 3\n",
      "69 : 3\n",
      "72 : 2\n",
      "75 : 2\n",
      "78 : 3\n",
      "81 : 5\n",
      "84 : 3\n",
      "87 : 3\n",
      "90 : 6\n",
      "93 : 3\n",
      "96 : 3\n",
      "99 : 3\n",
      "102 : 3\n",
      "105 : 5\n",
      "Most common length is 51 nts\n"
     ]
    }
   ],
   "source": [
    "# print all tallies for informational purposes\n",
    "for name in sorted(lenDict.keys()):\n",
    "    print name, \":\", lenDict[name]\n",
    "\n",
    "# now to get the max length, we can sort the keys by value\n",
    "sortedLens = sorted(lenDict, key=lenDict.get) #this returns a list of the keys sorted by value\n",
    "\n",
    "# this sorts from smallest to largest, so we take the last element\n",
    "mostCommon = sortedLens[-1]\n",
    "print \"Most common length is\", mostCommon, \"nts\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 5. Codon table (6pts)\n",
    "\n",
    "For this question, use `codon_table.txt`, which contains a list of all possible codons and their corresponding amino acids. We will be using this info to create a dictionary, which will allow us to translate a nucleotide sequence into amino acids. Each part of this question builds off the previous parts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(A)** Thinkin' question (short answer, not code): If we want to create a codon dictionary and use it to translate nucleotide sequences, would it be better to use the codons or amino acids as keys? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Codons should be the keys, since we are starting with nucleotide sequence. That is the info we'll want to use to retrieve the amino acid. \n",
    "\n",
    "> If you were instead going from protein --> nucleotide, then you'd want the amino acids to be the keys. (But that can be problematic because a single amino acid usually maps to more than one codon!) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(B)** Read in `codon_table.txt` (note that it has a header line) and use it to create a codon dictionary. Then use `raw_input()` prompt the user to enter a single codon (e.g. ATG) and print the amino acid corresponding to that codon to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Codon to translate: ATG\n",
      "ATG --> M\n"
     ]
    }
   ],
   "source": [
    "inFile = \"codon_table.txt\"\n",
    "codon2aa = {}\n",
    "\n",
    "ins = open(inFile, 'r')\n",
    "ins.readline() #skip header\n",
    "\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\n')\n",
    "    lineParts = line.split() \n",
    "    codon = lineParts[0]\n",
    "    aa = lineParts[1]\n",
    "    \n",
    "    if codon not in codon2aa:\n",
    "        codon2aa[codon] = aa\n",
    "    else:\n",
    "        print \"Warning! Multiple entries found for the same codon (\" + codon + \"). Skipping.\"\n",
    "        \n",
    "ins.close()\n",
    "\n",
    "request = raw_input(\"Codon to translate: \").upper() #covert to uppercase, just in case\n",
    "if request in codon2aa:\n",
    "    print request, \"-->\", codon2aa[request]\n",
    "else:\n",
    "    print \"Did not recognize that codon.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(C)** Now we will adapt the code in (B) to translate a longer sequence. Instead of prompting the user for a single codon, allow them to enter a longer sequence. First, check that the sequence they entered has a length that is a multiple of 3 (Hint: use the mod operator, %), and print an error message if it is not. If it is valid, then go on to translate every three nucleotides to an amino acid. Print the final amino acid sequence to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequence to translate (multiple of 3): ATGGCTCGATAGCTATTTAGCTAG\n",
      "Your protein sequence is: MAR*LFS*\n"
     ]
    }
   ],
   "source": [
    "inFile = \"codon_table.txt\"\n",
    "codon2aa = {}\n",
    "\n",
    "ins = open(inFile, 'r')\n",
    "ins.readline() #skip header\n",
    "\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\n')\n",
    "    lineParts = line.split() \n",
    "    codon = lineParts[0]\n",
    "    aa = lineParts[1]\n",
    "    \n",
    "    if codon not in codon2aa:\n",
    "        codon2aa[codon] = aa\n",
    "    else:\n",
    "        print \"Warning! Multiple entries found for the same codon (\" + codon + \"). Skipping.\"\n",
    "        \n",
    "ins.close()\n",
    "\n",
    "\n",
    "# get user input\n",
    "request = raw_input(\"Sequence to translate (multiple of 3): \").upper()\n",
    "protSeq = \"\"\n",
    "\n",
    "if (len(request) % 3) == 0:\n",
    "    \n",
    "    # this indexing/slicing is tricky! definitely test this sort of thing to make sure you get it right.\n",
    "    for i in range(0,len(request),3):\n",
    "        codon = request[i:i+3]\n",
    "        if codon in codon2aa:\n",
    "            protSeq = protSeq + codon2aa[codon]\n",
    "        else:\n",
    "            print \"Warning! Unrecognized codon (\"+codon+\"). Using X as a place holder.\"\n",
    "            protSeq = protSeq + \"X\"\n",
    "            \n",
    "    print \"Your protein sequence is:\", protSeq\n",
    "    \n",
    "else:\n",
    "    print \"Please enter a sequence length that is a multiple of 3.\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(D)** Now, instead of taking user input, you will apply your translator to a set of sequences stored in a file. Read in the sequences from `sequences3.txt` (assume each line is a separate sequence), translate it to amino acids, and print it to a new file called `proteins.txt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "inFile = \"codon_table.txt\"\n",
    "codon2aa = {}\n",
    "\n",
    "ins = open(inFile, 'r')\n",
    "ins.readline() #skip header\n",
    "\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\n')\n",
    "    lineParts = line.split() \n",
    "    codon = lineParts[0]\n",
    "    aa = lineParts[1]\n",
    "    \n",
    "    if codon not in codon2aa:\n",
    "        codon2aa[codon] = aa\n",
    "    else:\n",
    "        print \"Warning! Multiple entries found for the same codon (\" + codon + \"). Skipping.\"\n",
    "        \n",
    "ins.close()\n",
    "\n",
    "\n",
    "\n",
    "# read file of sequences\n",
    "inFile = \"sequences3.txt\"\n",
    "outFile = \"proteins.txt\"\n",
    "\n",
    "ins = open(inFile, 'r')\n",
    "outs = open(outFile, 'w')\n",
    "\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\n')\n",
    "    protSeq = \"\" #best to define this with the loop so it's re-created for each separate sequence.\n",
    "    \n",
    "    if (len(line) % 3) == 0:\n",
    "        for i in range(0,len(line),3):\n",
    "            codon = line[i:i+3]\n",
    "            if codon in codon2aa:\n",
    "                protSeq = protSeq + codon2aa[codon]\n",
    "            else:\n",
    "                print \"Warning! Unrecognized codon (\"+codon+\"). Using X as a place holder.\"\n",
    "                protSeq = protSeq + \"X\"\n",
    "                \n",
    "        outs.write(protSeq + '\\n') # write to output file\n",
    "        \n",
    "    else:\n",
    "        print \"Encountered sequence length that is not a multiple of 3. Skipping it. Sequence:\", line\n",
    "        \n",
    "outs.close()\n",
    "ins.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "---\n",
    "## Bonus question: Parsing fasta files (+2 bonus pts)\n",
    "\n",
    "This question is optional, but if you complete it, I'll give you two bonus points. You won't lose points if you skip it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write code that reads sequences from a fasta file and stores them in a dictionary according to their header (i.e. use the header line as the key and sequence as the value). You will use `horrible.fasta` to test your code. \n",
    "\n",
    "If you are not familiar with fasta files, they have the following general format:\n",
    "\n",
    "```\n",
    ">geneName1\n",
    "ATCGCTAGTCGATCGATGGTTTCGCGTAGCGTTGCTAGCGTAGCTGATG\n",
    "TCGATCGATGGTTTCGCGTAGCGTTGCTAGCGTAGCTGATGATGCTCAA\n",
    "GCTGGATGGCTAGCTGATGCTAG\n",
    ">geneName2\n",
    "ATCGATGGGCTGGATCGATGCGGCTCGGCGATCGA\n",
    "...\n",
    "```\n",
    "\n",
    "There are many slight variations; for example the header often contains different information, depending where you got the file from, and the sequence for a given entry may span any number of lines. To write a good fasta parser, you must make as few assumptions about the formatting as possible. This will make your code more \"robust\". \n",
    "\n",
    "For fasta files, pretty much the only things you can safely assume are that a new entry will be marked by the `>` sign, which is immediately followed by a (usually) unique header, and all sequence belonging to that entry will be located immediately below. However, you can't assume how many lines the sequence will take up.\n",
    "\n",
    "With this in mind, write a robust fasta parser that reads in `horrible.fasta` and stores each sequence in a dictionary according to its header line. Call the dictionary `seqDict`. Remove any newline characters. Don't include the `>` sign in the header. *Hint: use string slicing or `.lstrip()`*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ins = open(\"horrible.fasta\", 'r')\n",
    "seqDict = {}\n",
    "activeID = \"\"\n",
    "\n",
    "for line in ins:\n",
    "    line = line.rstrip('\\n')\n",
    "    \n",
    "    # if the first character is >, this line is a header.\n",
    "    if line[0] == \">\":\n",
    "        activeID = line[1:] \n",
    "        \n",
    "        if activeID in seqDict:\n",
    "            print \">>> Warning: repeat id:\", activeID, \"-- overwriting previous ID.\"\n",
    "        seqDict[activeID] = \"\"\n",
    "        \n",
    "    # otherwise, this is a sequence line--add it to the activeID entry\n",
    "    else:\n",
    "        seqDict[activeID] = seqDict[activeID] + line \n",
    "        \n",
    "ins.close()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you've written your code above and you think it works, run it and then run the following code to to spot-check whether you did everything correctly. If you didn't name your dictionary `seqDict`, you'll need to change it below to whatever you named your dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Congrats, you passed all my tests!\n"
     ]
    }
   ],
   "source": [
    "error = False\n",
    "if \">varlen2_uc001pmn.3_3476\" in seqDict:\n",
    "    print \"Remove > chars from headers!\"\n",
    "    error = True\n",
    "elif \"varlen2_uc001pmn.3_3476\" not in seqDict:\n",
    "    print \"Something's wrong with your dictionary: missing keys\"\n",
    "    error = True\n",
    "if \"varlen2_uc021qfk.1>2_1472\" not in seqDict:\n",
    "    print \"Only remove the > chars from the beginning of the header!\"\n",
    "    error = True\n",
    "if len(seqDict[\"varlen2_uc009wph.3_423\"]) > 85:\n",
    "    if \"\\n\" in seqDict[\"varlen2_uc009wph.3_423\"]:\n",
    "        print \"Remove newline chars from sequences\"\n",
    "        error = True\n",
    "    else:\n",
    "        print \"Length of sequences longer than expected for some reason\"\n",
    "        error = True\n",
    "elif len(seqDict[\"varlen2_uc009wph.3_423\"]) < 85:\n",
    "    print \"Length of sequences shorter than expected for some reason\"\n",
    "    error = True\n",
    "\n",
    "if error == False:\n",
    "    print \"Congrats, you passed all my tests!\""
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}