2016-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming with Python\n",
    "\n",
    "Derived from [Novice Python lesson using Python 2.7 - Copyright © Software Carpentry](https://github.com/swcarpentry/python-novice-inflammation-2.7) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Launch Jupyter Notebook\n",
    "- Navigate to the directory with your bash files\n",
    "- Click New->Notebook->Python [conda root]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python & Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Explain the notebook. Environment for using python that's great for teaching and exploring\n",
    "- Rename our untitled notebook and save it\n",
    "- Explore cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The gray boxes are cells\n",
    "We write programs in the cells, and programs are just telling the computer to do something\n",
    "So let's tell the computer to add 5 and 3\n",
    "We start with the thing we want the computer to do (print), then "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "print 5 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numbers are great, but we often need more than a calculator. Since we're programmers now, let's write a hello world program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-10-b9f0e0801bac>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-10-b9f0e0801bac>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    print Hello world\u001b[0m\n\u001b[0m                    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print Hello world"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK so python didn't like that, but there's a lot to learn here\n",
    "\n",
    "- It's easy to make mistakes, don't be discouraged\n",
    "- Errors can be really helpful.\n",
    "- Numbers are just numbers, but text needs quotes.\n",
    "- we can go back, edit cells, and run them again!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World\n"
     ]
    }
   ],
   "source": [
    "print 'Hello, World'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This value here is what we call a \"string\". A string is a sequence of characters that make up words or phrases. Values like strings and integers can be stored in variables. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We don't have to print the message directly, we can store it in a variable and then print the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aloha\n"
     ]
    }
   ],
   "source": [
    "greeting = 'Aloha'\n",
    "print greeting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can print multiple things by inserting commas. So let's all greet our neighbor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello John\n"
     ]
    }
   ],
   "source": [
    "neighbor = 'John'\n",
    "print 'Hello', neighbor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, we can work with numbers too"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My daughter is 3 years old.\n",
      "Next year she will be 4\n"
     ]
    }
   ],
   "source": [
    "age = 3\n",
    "print 'My daughter is', age, 'years old.'\n",
    "print 'Next year she will be', age + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Floats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we've seen integers and strings. Integers are good for counting things, and strings are good for storing text. There are a few other data types:\n",
    "\n",
    "For numeric data, there's also `float` - for decimal numbers/fractions and `complex` for complex numbers.\n",
    "\n",
    "And you create floats just by using a decimal point in your number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50.0\n"
     ]
    }
   ],
   "source": [
    "lb = 50.0\n",
    "kg = lb * 2.2\n",
    "print lb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's common to use integers for counting things, but be careful if you divide integers in Python 2, you'll always get an integer back!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9/10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead, you can simply add a decimal point to one of the numbers. Which reminds me, any time you do something that's not obvious why you're doing it in a program, it's a good idea to put a comment. Comments are just little notes in your code for yourself or other humans to read."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9.0 / 10.0 # Make sure we divide with floats, otherwise we get integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Summary slide in presentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've used strings to hold small bits of text - words, sentences, etc. We'll use them all the time in Python, and usually with single quotes, though double quotes work too.\n",
    "\n",
    "Strings are one of Python's `sequence` types. The string `'abc'` is a sequence of the characters `a`, `b`, then `c`, in that order.\n",
    "\n",
    "Since a sequence is made up of elements, we can access those elements individually by using an **integer index** and **square brackets**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D\n"
     ]
    }
   ],
   "source": [
    "name = 'Daniel'\n",
    "print name[0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that Python starts counting at **0**. So the _first letter_ in our **name** string is at `name[0]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "n\n",
      "l\n"
     ]
    }
   ],
   "source": [
    "print name[1]\n",
    "print name[2]\n",
    "print name[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also extract **slices** of strings. We do that with the start position and the end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Daniel\n",
      "iel\n"
     ]
    }
   ],
   "source": [
    "print name[0:6]\n",
    "print name[3:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or check if a letter exists in a string:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**True** is actually a new type of data called a boolean. We'll cover these later, but it's very helpful to do things like check membership or compare two numbers, and boolean values are used for that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also check if a letter does **not** exist, by using the word `not`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' not in name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Summary slide in presentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assigning Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will be using variables extensively to store data and call it back between different statements. Variables act like a sticky note. You create a label and stick it on a piece of data. And anywhere we'd use a value directly (like printing or adding), we can instead use the variable name:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "print 3 + 3\n",
    "sum = 3 + 3\n",
    "print sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `=` means to assign the expression on the right to the variable on the left. Variable names (like sticky notes) can be reused, and it works like moving the sticky note:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "x = 6\n",
    "x = 4\n",
    "print x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as I can put multiple sticky notes on the same object, I can have multiple variables referencing the same piece of data, and later move them around:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = y = 'pencil'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pencil pencil\n"
     ]
    }
   ],
   "source": [
    "print x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's change `x` to a different value, `5`. What happens to `y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 pencil\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "print x,y "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing to keep in mind is that variables don't **remember** where they came from. When you use a variable in a computation, Python will use the value of that variable when the code is run. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 4\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "b = a + 1\n",
    "a = 0\n",
    "print a, b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This isn't surprising if you think of the program as just a list of steps, but if you expect it to behave like a spreadsheet, it may be surprising."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Summary slide in presentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with a DNA Sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start working with genomic data. Here's a DNA sequence we can all copy/paste from the web site. This is a string, and we are going to store it in a variable called `seq10`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "seq10 = 'ACCTGCATGC'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, we can get the 10th base by indexing into the string at position 10. Remember, Python starts counting at 0!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C G T\n"
     ]
    }
   ],
   "source": [
    "b10 = seq10[9]\n",
    "b9 = seq10[8]\n",
    "b8 = seq10[7]\n",
    "print b10, b9, b8\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can combine multiple strings together using the plus sign, so we could recombine these 3 bases now in a reverse order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "r3 = b10 + b9 + b8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CGT\n"
     ]
    }
   ],
   "source": [
    "print r3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But, when we combine strings, we **always** get a new string. We can't modify (or mutate) the existing string. But, what we **can** do is reassign a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'r3' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-fbfbf23cf48f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mr3\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'G'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'r3' is not defined"
     ]
    }
   ],
   "source": [
    "r3[2] = 'G'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CGT CGG\n"
     ]
    }
   ],
   "source": [
    "old3 = r3\n",
    "r3 = b10 + b9 + 'G'\n",
    "print old3, r3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We call strings \"immutable\" since they cannot be mutated. We'll cover some data types that are mutable, but when working with strings, we have to build new ones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we'd like to perform an operation on the sequence: **reverse complement**. It's a useful process when working with sequences, and it's a great example of a problem you can write down and explain, but may not immediately know how to program.\n",
    "\n",
    "With any programming endeavor, we'll start by breaking the problem down into parts and then combining them. So to reverse-complemment a sequence, first we'll learn how to reverse it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reversing - loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** slide in presentation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CGTACGTCCA\n"
     ]
    }
   ],
   "source": [
    "rev10 = seq10[9] + seq10[8] + seq10[7] + seq10[6] + seq10[5] + seq10[4] + seq10[3] + seq10[2] + seq10[1] + seq10[0]\n",
    "print rev10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but that's a bad approach for two reasons:\n",
    "\n",
    "1.  It doesn't scale:\n",
    "    if we want to print the characters in a string that's hundreds of letters long,\n",
    "    we'd be better off just typing them in.\n",
    "\n",
    "1.  It's fragile:\n",
    "    if we give it a longer sequence,\n",
    "    it only reverses part of the data,\n",
    "    and if we give it a shorter one,\n",
    "    it produces an error because we're asking for characters that don't exist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A better way to do this is with a loop. Loops work on sequences like strings, and let you do something with each element, no matter how long the sequence is. Let's start with a basic loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "C\n",
      "C\n",
      "T\n",
      "G\n",
      "C\n",
      "A\n",
      "T\n",
      "G\n",
      "C\n"
     ]
    }
   ],
   "source": [
    "for s in seq10:\n",
    "    print s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A few things happened here. \n",
    "\n",
    "1. First, we introduced a couple new keywords `for` and `in`. This constructs the loop and says we want to work on each element in `seq10`. This line must end with a **colon**.\n",
    "2. Second, we created a new variable `s`. This is called a **loop variable** that because it changes at each iteration of the loop.\n",
    "3. Third, we indented the code that we want to repeat. In some languages you use special words or characters to start or end loops. In Python, the body of the loop is defined by the lines that are indented after the colon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before\n",
      "Inside: a\n",
      "Inside: b\n",
      "Inside: c\n",
      "After\n"
     ]
    }
   ],
   "source": [
    "print 'Before'\n",
    "for l in 'abc':\n",
    "    print 'Inside:', l\n",
    "print 'After'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do other things in the body - they don't have to relate to the loop variable. For example, if we want to count how long the sequence is, we can use a variable that we add one to every time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "for s in seq10:\n",
    "    count = count + 1\n",
    "print count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, I think we're ready to reverse the sequence. Let's make this a hands-on exercise to write some code that reverses the sequence in `seq10` and puts it in a variable called `rev10`. Remember, you can add strings together and the order is important!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise in presentation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CGTACGTCCA\n"
     ]
    }
   ],
   "source": [
    "rev10 = ''\n",
    "for s in seq10:\n",
    "    rev10 = s + rev10\n",
    "print rev10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Summary slide in presentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Intro Dictionaries slide in presentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries - lookups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a data type called a dictionary that's great for looking things up. It associates pairs of things together: a key and a value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say we want to keep track of the counts of the nucleotides in our sequence. We can create a dictionary where the keys are the letters, and the values are quantity of each:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 2, 'C': 4, 'T': 2, 'G': 2}\n"
     ]
    }
   ],
   "source": [
    "nucs = {'A': 2, 'C': 4, 'G': 2, 'T': 2}\n",
    "print nucs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like a string, we access elements in the dictionary with square brackets `[]`. But, instead of a number, we use the key to index. So to ask *how many A's do I have*, you do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have 2 As\n"
     ]
    }
   ],
   "source": [
    "print 'I have', nucs['A'], 'As'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But unlike a string, dictionaries are **mutable**. This means we can change their contents. Let's change the number of As to 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now I have 3 As\n"
     ]
    }
   ],
   "source": [
    "nucs['A'] = 3\n",
    "print 'Now I have', counts['A'], 'As'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can use a variable as the key, so let's choose a specific letter and put that in the variable `nuc`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have 4 Cs\n"
     ]
    }
   ],
   "source": [
    "nuc = 'C'\n",
    "print 'I have', nucs[nuc], nuc + 's'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since dictionaries are collections of items, we can loop over them.  Let's see what happens when we loop over our fruits dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "C\n",
      "T\n",
      "G\n"
     ]
    }
   ],
   "source": [
    "for n in nucs:\n",
    "    print n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we loop over the dictionary, the **loop variable** is set to each **key**. The loop doesn't give us the **value**, but it's easy to get since we have the key and the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A 3\n",
      "C 4\n",
      "T 2\n",
      "G 2\n"
     ]
    }
   ],
   "source": [
    "for n in nucs:\n",
    "    qty = nucs[n]\n",
    "    print n, qty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an exercise, let's get the total quantity of nucleotides we have. This loop should look a lot like counting the bases in the sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are great because they're flexible, so we can use them to look up anything like complementary bases. So let's start by creating a dictionary with the complements for A and T."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "complements = {'A':'T', 'T':'A'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So if I want to read the complement of `A`, I write `complements['A']`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T\n"
     ]
    }
   ],
   "source": [
    "print complements['A']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We just have A and T here. With dictionaries, we can add more items or even change existing ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "complements['C'] = 'G'\n",
    "complements['G'] = 'C'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 'T', 'C': 'G', 'T': 'A', 'G': 'C'}\n"
     ]
    }
   ],
   "source": [
    "print complements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, I can complement my sequence from before by looking up the complement inside a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCTGCATGC\n",
      "CGTACGTCCA\n",
      "GCATGCAGGT\n"
     ]
    }
   ],
   "source": [
    "revcomp10 = ''\n",
    "# starting with rev10, the already reversed sequence\n",
    "for s in rev10:\n",
    "    c = complements[s]\n",
    "    revcomp10 = revcomp10 + c\n",
    "print seq10\n",
    "print rev10\n",
    "print revcomp10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "We've looked at strings and dictionaries as collection types. There's another one that's really useful, and it's called a list. It's an ordered collection of elements. Lists use the `[]` square brackets, and elments are separated by commas.\n",
    "\n",
    "Here's one that contains our 3 sequences.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCTGCATGC\n",
      "CGTACGTCCA\n",
      "GCATGCAGGT\n"
     ]
    }
   ],
   "source": [
    "sequences = [seq10, rev10, revcomp10]\n",
    "for seq in sequences:\n",
    "    print seq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists, unlike strings, are mutable. So I can add or remove to a list, reorder it, or swap items out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sequences[0] = 'AAAAAGGGGG'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['AAAAAGGGGG', 'CGTACGTCCA', 'GCATGCAGGT']\n"
     ]
    }
   ],
   "source": [
    "print sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both dictionaries and lists let you delete things with the `del` keyword - again because they're mutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['CGTACGTCCA', 'GCATGCAGGT']\n"
     ]
    }
   ],
   "source": [
    "del sequences[0]\n",
    "print sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Like a list, but immutable. A frozen list. Instead of square brackets, you use parenthesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RNA\n"
     ]
    }
   ],
   "source": [
    "sequence_types = ('RNA','DNA','Protein')\n",
    "print sequence_types[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence_types[1] = 'dna'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Summary slide in presentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making choices / Conditionals\n",
    "\n",
    "When writing programs, it's very handy to examine some data or some results, and make a decision about what to do next. This is called a conditional, and most common version is the `if-else`.\n",
    "\n",
    "Here's how it works. we start with an `if`, and then we write some expression that will either be **True** or **False**. Then we write a colon, and indent what should happen **if** the expression was **True**. \n",
    "\n",
    "We can also write what should happen if the expression was **False**, after an `else`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequence contains GC\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "if 'GC' in seq10:\n",
    "    print 'Sequence contains GC'\n",
    "else:\n",
    "    print 'Sequence does not contain GC'\n",
    "print 'done'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only one or the other is ever executed\n",
    "\n",
    "Conditional statements don't have to include an `else`. If there isn't one, Python simply does nothing if the test is false."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Instruction slide in presentation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GC-content percentage: 60 %\n"
     ]
    }
   ],
   "source": [
    "gc = 0\n",
    "atgc = 0\n",
    "for s in seq10:\n",
    "    if s == 'G': # notice the double indent\n",
    "        gc = gc + 1\n",
    "    if s == 'C':\n",
    "        gc = gc + 1\n",
    "    atgc = atgc + 1 # outside the ifs\n",
    "# Outside the loop\n",
    "percent = (gc * 100) / atgc\n",
    "print 'GC-content percentage:', percent, '%'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that works, but we've repeated ourselves. In both cases (`G` and `C`), we're running the same code. One of Python's philosophies is _Don't Repeat Yourself_, and it's generally a good idea.\n",
    "\n",
    "So, when we want to check if one condition is true **or** another, we use the word **or** in between the two tests. So we can make this code a little shorter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GC-content percentage: 60 %\n"
     ]
    }
   ],
   "source": [
    "gc = 0\n",
    "atgc = 0\n",
    "for s in seq10:\n",
    "    if s == 'G' or s == 'C':\n",
    "        gc = gc + 1\n",
    "    atgc = atgc + 1 # outside the ifs\n",
    "# Outside the loop\n",
    "percent = (gc * 100) / atgc\n",
    "print 'GC-content percentage:', percent, '%'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, another thing we can test for is if values are greater or less than others. We can classify these percentages as high, normal, or low. Let's say anything below 35 is low, anything from 36-55 is normal, and anything above 56 is high. We start by writing the first condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Low\n"
     ]
    }
   ],
   "source": [
    "percent = 20\n",
    "if percent < 35:\n",
    "    print 'Low'\n",
    "elif percent < 55:\n",
    "    print 'Normal'\n",
    "else:\n",
    "    print 'High'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Summary slide in presentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coffee Break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've said that these sequence types have a lot of common functionality - We can access individual elements, slice them, or loop over them. But there's a lot more things we can do with **functions**. There's about 75 functions that are built-in and just ready to use. They can do simple things like tell you the length of a collection, or more advanced things like sorting, working with files, or converting between data types.\n",
    "\n",
    "To use a function, you type its name, followed by parenthesis. Let's use the **len** function to get the length of our sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print len(seq10) # much less code than writing a loop!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And that works on any collection - so, dictionaries, lists, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 2\n"
     ]
    }
   ],
   "source": [
    "print len(complements), len(sequences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's the `sorted` function that takes a list and returns a new list in order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "x = [7,3,2,8,4]\n",
    "y = sorted(x)\n",
    "print y\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions open up a lot of possibilities. They're bits of code you can use, but don't have to write. One really important function is called **help**. Python has its own built-in documentation on functions, and to use it, you just type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sorted in module __builtin__:\n",
      "\n",
      "sorted(...)\n",
      "    sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sorted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's also plenty of documentation on the internet: https://docs.python.org/2/library/functions.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many data types have their own functions too. We talked about strings, and they often contain multiple words separated by spaces. So there's a function called **split()** that makes a list of those words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['rna', 'dna', 'protein']\n"
     ]
    }
   ],
   "source": [
    "seqs = 'rna dna protein' #This order is important for sorting later\n",
    "seqs_list = seqs.split()\n",
    "print seqs_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function is **part of** the string, so when we want to use the function, we start with the string, then type a dot and the function name. We don't need to put anything in the parenthesis. There are thousands of functions that are **part of** different data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise slide in presentation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']\n",
      "['RED', 'ORANGE', 'YELLOW', 'GREEN', 'BLUE', 'INDIGO', 'VIOLET']\n",
      "['VIOLET', 'INDIGO', 'BLUE', 'GREEN', 'YELLOW', 'ORANGE', 'RED']\n"
     ]
    }
   ],
   "source": [
    "spectrum = 'red orange yellow green blue indigo violet'\n",
    "colors = spectrum.split()\n",
    "print colors\n",
    "uppercased = spectrum.upper().split()\n",
    "print uppercased\n",
    "uppercased.reverse()\n",
    "print uppercased\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've already written code that performs basic operations on genomic sequences: reverse complement and calculating GC content percentage. But that code only runs on our example seq10, and it would be more useful if we could easily run it on any sequence\n",
    "\n",
    "To do that, we're going to write our own functions to do those."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write a very simple function that we can understand\n",
    "\n",
    "- Start with def, meaning we define a function\n",
    "- Give it a name that says what it does, in this case **double**\n",
    "- Open parenthesis and create some argument variables (more on that in a minute). \"What do you want me to double\"\n",
    "- Close the parenthesis and type a colon (like loops or conditionals)\n",
    "- Write indented code that does the work of our function\n",
    "- returns it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def double(x):\n",
    "    result = x * 2\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling your own functions is the same as calling the built-in ones - just use the name and parenthesis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "doubled = double(100)\n",
    "print doubled\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A neat benefit is that we can double lots of things! If we double a string, we get..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCCACCC\n"
     ]
    }
   ],
   "source": [
    "print double('ACCC')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arguments and return values\n",
    "\n",
    "Within our function we use this variable `x`, which we didn't assign traditionally. It's a function argument, meaning that it will be set with whatever we put inside the parenthesis. \n",
    "\n",
    "While this is different than saying x = 100 explicitly, it's actually a great feature. It's the reason we can reuse functions and not have them interfere with each other.\n",
    "\n",
    "Every time we call `double`, that function gets its own private `x` to use. If we have a variable called x in other places, it won't replace or conflict with the one inside our function. Which is great, because I use simple short names all the time!\n",
    "\n",
    "We also have this new keyword, `return`. Most functions will use this, where you want to do some work or computation and return a result. In this example, you'd expect a function with an action name like `double` would do some work and provide you the result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Reverse-complementing\n",
    "\n",
    "We have two operations that are perfect to turn into functions, then we can use them independently or together."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To write a function that reverses a sequence, we want to take an input value, the sequence, reverse it, and return that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def reverse(seq):\n",
    "    rev = ''\n",
    "    for s in seq:\n",
    "        rev = s + rev\n",
    "    return rev\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GTCA\n"
     ]
    }
   ],
   "source": [
    "print reverse('ACTG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCTGCATGC\n",
      "CGTACGTCCA\n"
     ]
    }
   ],
   "source": [
    "print seq10\n",
    "print reverse(seq10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To test that the function works, we could eyeball it, and we can also test that double-reversing gives us the original sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ACCTGCATGC'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse(reverse(seq10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can move onto complementing. So let's pull up that code and move it into a function. Let's again tidy up our variable names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def complement(seq):\n",
    "    comp = ''\n",
    "    for s in seq:\n",
    "        c = complements[s]\n",
    "        comp = comp + c\n",
    "    return comp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCTGCATGC\n",
      "TGGACGTACG\n"
     ]
    }
   ],
   "source": [
    "print seq10\n",
    "print complement(seq10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That works, but there's still one piece that's odd. We have our **seq** variable that's private to this function and nobody else can access it. But we're depending on this complements variable, which we don't create or check.\n",
    "\n",
    "That's called a global variable, because it exists outside of a function and it's available for reading and writing everywhere. And it's dangerous because \n",
    "\n",
    "1. If we run this function without assigning `complements`, the function will fail\n",
    "2. If we run it with `complements` set to something we don't expect, our function will give us the wrong answer\n",
    "3. We can't look at this function and know what it's going to do, because we don't know what complements is or where it comes from\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some things do need to be global variables, but generally we should avoid them. So here, I'm going to create a **local** variable inside the function with my complements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def complement(seq):\n",
    "    complements = {'A': 'T', 'C': 'G', 'T': 'A', 'G': 'C'}\n",
    "    comp = ''\n",
    "    for s in seq:\n",
    "        c = complements[s]\n",
    "        comp = comp + c\n",
    "    return comp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TGG'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complement('ACC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TGG'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complements = 42\n",
    "complement('ACC')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we've got solid functions for reverse and complement. We've tested them independently, so now let's put them together in another function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def reverse_complement(seq):\n",
    "    return reverse(complement(seq))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TTGG'"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse_complement('CCAA')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise slide in presentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Summary slide in presentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When working with real-world data, it will typically be in a file, and **not** in your code. Fortunately, Python has functions to read files. These work with simple text files, and if you need to handle images or other binary formats, there ar elibraries that can help with that.\n",
    "\n",
    "Sequence data is typically in stored text files, like fasta. So let's walk through reading one of those."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Open and close\n",
    "\n",
    "When you use a word processor or spreadsheet, you open files, work with them, and then close them when you're done. In python, you do the same thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">lcl|AE014075.1_gene_2 [locus_tag=c0002] [location=534..911]\n",
      "\n",
      "GTGTTCTACAGAGAGAAGCGTAGAGCAATAGGCTGTATTTTGAGAAAGCTGTGTGAGTGGAAAAGTGTAC\n",
      "\n",
      "GGATTCTGGAAGCTGAATGCTGTGCAGATCATATCCATATGCTTGTGGAGATCCCGCCCAAAATGAGCGT\n",
      "\n",
      "ATCAGGCTTTATGGGATATCTGAAAGGGAAAAGCAGTCTGATGCCTTACGAGCAGTTTGGTGATTTGAAA\n",
      "\n",
      "TTCAAATACAGGAACAGGGAGTTCTGGTGCAGAGGGTATTACGTCGATACGGTGGGTAAGAACACGGCGA\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open('ae.fa')\n",
    "for line in f:\n",
    "    print line\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading lines\n",
    "\n",
    "When we work with text files, we read them line by line in a loop. Each line of text from the file is set into our loop variable, and we print it out from the loop.\n",
    "\n",
    "You'll probably notice that we have a blank line in between each line from the file. This is because the line actually includes the `\\n` newline character at the end. Now that's actually **in** the file, but if we know we have the whole line, we can strip that off with the `strip()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">lcl|AE014075.1_gene_2 [locus_tag=c0002] [location=534..911]\n",
      "GTGTTCTACAGAGAGAAGCGTAGAGCAATAGGCTGTATTTTGAGAAAGCTGTGTGAGTGGAAAAGTGTAC\n",
      "GGATTCTGGAAGCTGAATGCTGTGCAGATCATATCCATATGCTTGTGGAGATCCCGCCCAAAATGAGCGT\n",
      "ATCAGGCTTTATGGGATATCTGAAAGGGAAAAGCAGTCTGATGCCTTACGAGCAGTTTGGTGATTTGAAA\n",
      "TTCAAATACAGGAACAGGGAGTTCTGGTGCAGAGGGTATTACGTCGATACGGTGGGTAAGAACACGGCGA\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open('ae.fa')\n",
    "for line in f:\n",
    "    line = line.strip()\n",
    "    print line\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise in presentation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def read_fasta(filename):\n",
    "    sequence = ''\n",
    "    f = open(filename)\n",
    "    for line in f:\n",
    "        line = line.strip()\n",
    "        if not '>' in line:\n",
    "            # Append to the last sequence\n",
    "            sequence = sequence + line\n",
    "    f.close()\n",
    "    return sequence\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GTGTTCTACAGAGAGAAGCGTAGAGCAATAGGCTGTATTTTGAGAAAGCTGTGTGAGTGGAAAAGTGTACGGATTCTGGAAGCTGAATGCTGTGCAGATCATATCCATATGCTTGTGGAGATCCCGCCCAAAATGAGCGTATCAGGCTTTATGGGATATCTGAAAGGGAAAAGCAGTCTGATGCCTTACGAGCAGTTTGGTGATTTGAAATTCAAATACAGGAACAGGGAGTTCTGGTGCAGAGGGTATTACGTCGATACGGTGGGTAAGAACACGGCGA\n"
     ]
    }
   ],
   "source": [
    "print read_fasta('ae.fa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TCGCCGTGTTCTTACCCACCGTATCGACGTAATACCCTCTGCACCAGAACTCCCTGTTCCTGTATTTGAATTTCAAATCACCAAACTGCTCGTAAGGCATCAGACTGCTTTTCCCTTTCAGATATCCCATAAAGCCTGATACGCTCATTTTGGGCGGGATCTCCACAAGCATATGGATATGATCTGCACAGCATTCAGCTTCCAGAATCCGTACACTTTTCCACTCACACAGCTTTCTCAAAATACAGCCTATTGCTCTACGCTTCTCTCTGTAGAACAC\n"
     ]
    }
   ],
   "source": [
    "print reverse_complement(read_fasta('ae.fa'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scripts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've done a good job of organizing our code into functions here, but we've only been running them from this notebook. So next, we're going to take our code and put it in a script - starting with the `read_sequence` function.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is going to be very familiar, since we're doing the same thing we did in bash, just with a different language!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ nano read_fasta.py`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting read_fasta_v1.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile read_fasta_v1.py\n",
    "def read_fasta(filename):\n",
    "    sequence = ''\n",
    "    f = open(filename)\n",
    "    for line in f:\n",
    "        line = line.strip()\n",
    "        if not '>' in line:\n",
    "            # Append to the last sequence\n",
    "            sequence = sequence + line\n",
    "    f.close()\n",
    "    return sequence\n",
    "\n",
    "print read_fasta('ae.fa')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting read_fasta_v2.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile read_fasta_v2.py\n",
    "import sys\n",
    "\n",
    "def read_fasta(filename):\n",
    "    sequence = ''\n",
    "    f = open(filename)\n",
    "    for line in f:\n",
    "        line = line.strip()\n",
    "        if not '>' in line:\n",
    "            # Append to the last sequence\n",
    "            sequence = sequence + line\n",
    "    f.close()\n",
    "    return sequence\n",
    "\n",
    "print read_fasta(sys.argv[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing read_fasta_v3.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile read_fasta_v3.py\n",
    "import sys\n",
    "\n",
    "def read_fasta(filename):\n",
    "    sequence = ''\n",
    "    f = open(filename)\n",
    "    for line in f:\n",
    "        line = line.strip()\n",
    "        if not '>' in line:\n",
    "            # Append to the last sequence\n",
    "            sequence = sequence + line\n",
    "    f.close()\n",
    "    return sequence\n",
    "\n",
    "if len(sys.argv) < 2:\n",
    "    print 'Usage:', sys.argv[0], '<sequence.fa>'\n",
    "    exit(1)\n",
    "\n",
    "print read_fasta(sys.argv[1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ python read_fasta.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our script reads our `ae.fa` file every time we run it, but we know most programs don't work that way. The programs we used in bash expected a data file as an *argument*, and that's a good convention for programs we write too.\n",
    "\n",
    "In Python, our program can get these arguments, but we have to load a library to access them. Google it!\n",
    "\n",
    "`import sys`\n",
    "\n",
    "https://docs.python.org/2/library/sys.html\n",
    "\n",
    "Libraries are incredibly useful - there are libraries for working with numeric and scientific data, generating plots, fetching data from the web, working with image and document files, databases, etc. And of course, there's a library for getting things like your script's command-line arguments.\n",
    "\n",
    "So, let's change our `read_fasta.py` program slightly\n",
    "\n",
    "    import sys\n",
    "    read_fasta(sys.argv[1])\n",
    "\n",
    "And run it. But what happens if we don't have a file name\n",
    "\n",
    "    if len(sys.argv) < 2:\n",
    "        print 'Usage:', sys.argv[0], '<sequence.fa>'\n",
    "        exit(1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Summary slide in presentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Putting it all together\n",
    "\n",
    "Advanced functions and plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def read_fasta_dict(filename):\n",
    "    \"\"\"\n",
    "    Reads sequences from a fasta file, and returns a dictionary that maps the \n",
    "    sequence description (key) to the sequence (value) \n",
    "    \n",
    "    For example:\n",
    "    \n",
    "    >seq1\n",
    "    AACCGG\n",
    "    >seq2\n",
    "    CCTTTG\n",
    "    \n",
    "    would result in {'seq1':'AACCGG','seq2':'CCTTG'}\n",
    "    \n",
    "    \"\"\"\n",
    "    sequences = {}\n",
    "    f = open(filename)\n",
    "    for line in f:\n",
    "        line = line.strip()\n",
    "        if '>' in line:\n",
    "            sequence_name = line # Need to keep track of the name since \"line\" will change next time\n",
    "            sequences[sequence_name] = ''\n",
    "        else:\n",
    "            # Append to the last sequence\n",
    "            sequences[sequence_name] = sequences[sequence_name] + line\n",
    "    f.close()\n",
    "    return sequences\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is an improved version of `gc_content_percentage` that uses string functions `count` and `len` to simplify the counting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def gc_content_percent(sequence):\n",
    "    \"\"\"\n",
    "    Calculates the GC-content percentage of the input sequence\n",
    "    Returns the percentage as an integer out of 100\n",
    "    \"\"\"\n",
    "    gc = sequence.count('G') + sequence.count('C')\n",
    "    atcg = len(sequence)\n",
    "    percent_gc = (gc * 100) / atcg\n",
    "    return percent_gc\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n"
     ]
    }
   ],
   "source": [
    "print gc_content_percent('GAAC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'>lcl|AE014075.1_gene_2 [locus_tag=c0002] [location=534..911]': 'GTGTTCTACAGAGAGAAGCGTAGAGCAATAGGCTGTATTTTGAGAAAGCTGTGTGAGTGGAAAAGTGTACGGATTCTGGAAGCTGAATGCTGTGCAGATCATATCCATATGCTTGTGGAGATCCCGCCCAAAATGAGCGTATCAGGCTTTATGGGATATCTGAAAGGGAAAAGCAGTCTGATGCCTTACGAGCAGTTTGGTGATTTGAAATTCAAATACAGGAACAGGGAGTTCTGGTGCAGAGGGTATTACGTCGATACGGTGGGTAAGAACACGGCGA'}"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "read_fasta_dict('ae.fa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "orchids = read_fasta_dict('ls_orchid.fasta')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "lengths, gc_contents = list(), list()\n",
    "for k,v in orchids.items():\n",
    "    lengths.append(len(v))\n",
    "    gc_contents.append(gc_content_percent(v))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting fasta_gc.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile fasta_gc.py\n",
    "# fasta_gc.py\n",
    "#\n",
    "# Reads a fasta file and prints out the GC content percentage of each sequence\n",
    "# in the file\n",
    "#\n",
    "# Usage: python fasta_gc.py sequences.fa\n",
    "#\n",
    "\n",
    "import sys\n",
    "\n",
    "def read_fasta_dict(filename):\n",
    "    \"\"\"\n",
    "    Reads sequences from a fasta file, and returns a dictionary that maps the \n",
    "    sequence description (key) to the sequence (value) \n",
    "    \n",
    "    For example:\n",
    "    \n",
    "    >seq1\n",
    "    AACCGG\n",
    "    >seq2\n",
    "    CCTTTG\n",
    "    \n",
    "    would result in {'seq1':'AACCGG','seq2':'CCTTG'}\n",
    "    \n",
    "    \"\"\"\n",
    "    sequences = {}\n",
    "    f = open(filename)\n",
    "    for line in f:\n",
    "        line = line.strip()\n",
    "        if '>' in line:\n",
    "            sequence_name = line # Need to keep track of the name since \"line\" will change next time\n",
    "            sequences[sequence_name] = ''\n",
    "        else:\n",
    "            # Append to the last sequence\n",
    "            sequences[sequence_name] = sequences[sequence_name] + line\n",
    "    f.close()\n",
    "    return sequences\n",
    "\n",
    "def gc_content_percent(sequence):\n",
    "    \"\"\"\n",
    "    Calculates the GC-content percentage of the input sequence\n",
    "    Returns the percentage as an integer out of 100\n",
    "    \"\"\"\n",
    "    gc = sequence.count('G') + sequence.count('C')\n",
    "    atcg = len(sequence)\n",
    "    percent_gc = (gc * 100) / atcg\n",
    "    return percent_gc\n",
    "\n",
    "def classify_percent(percent):\n",
    "    if percent < 35:\n",
    "        classification = 'Low'\n",
    "    elif percent < 55:\n",
    "        classification = 'Normal'\n",
    "    else:\n",
    "        classification = 'High'\n",
    "    return classification\n",
    "\n",
    "def main():\n",
    "    # Make sure we have a file name\n",
    "    if len(sys.argv) < 2:\n",
    "        print 'Usage: python', sys.argv[0], '<sequences.fa>'\n",
    "        exit(1)\n",
    "\n",
    "    filename = sys.argv[1]\n",
    "\n",
    "    # Read the sequences into a dictionary\n",
    "    sequences = read_fasta_dict(filename)\n",
    "\n",
    "    # Loop over the keys (sequence names) in the dictionary\n",
    "    for name in sequences:\n",
    "        sequence = sequences[name]\n",
    "        percent = gc_content_percent(sequence)\n",
    "        classification = classify_percent(percent)\n",
    "        print percent, classification, name\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most popular library for plotting in Python is `matplotlib`, and it's integrated into the notebook here, so you can see your plots inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x10f093850>"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh4AAAGHCAYAAAD/QltcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAAPYQAAD2EBqD+naQAAIABJREFUeJzt3Xm4XFWZ7/HvmzALJE6AgigYWqFVNNEwSONAO9A2Dleu\nGEXEK02rrWD0KniVSVpF7ACtIO0s41EUUVAEEYdGEqaEBpkNBEkIiUwJmACB5L1/rH2kUpyTnJNU\n1a5UfT/PU89J7b3O3u9ZhNTvrL322pGZSJIkdcKYuguQJEn9w+AhSZI6xuAhSZI6xuAhSZI6xuAh\nSZI6xuAhSZI6xuAhSZI6xuAhSZI6xuAhSZI6xuAh9amIuDMizh9Bu9dExIqI2HMEbX8XEb9pTYWS\nepHBQxqhiJgUERdFxOKIeCgiLo6InVfzPetFxE3VB/cnOlXrCI3meQkjbeszGCSt0np1FyCtCyJi\nInAZcBdwFDAW+Ajwu4iYnJl/GuZbDwGexzr8gZyZv4+IjTNzWd21SFr3OeIhjcyxwFJg18w8KTOn\nAa+mBJAvDvUNEbEFcARwHBCdKDIiNmrHcQ0dklrF4CGNzB7ArzNz0eCGzFwA/B7454jYZIjvOQ64\nGThrNCeKiLERcUREzI6IRyNiTkR8ISI2aGp3Z0ScHxFvjIirI+IR4OCG/ftHxJURsSQiHoiI30fE\nG4Y436urdo9ExO0R8b6m/UPO8YiIg6sal0bEFRGxxyh+xjdExGUR8WBEPBwRt0TEF5rabBARx0TE\nn6p+uCsivjxEP2wQESdGxF+qS2A/jYitq5qPbGj3/YiYM0QtR0fEiiG27x8R11Q/3/0RMRAR2zS1\n+V1EXB8RO0bEb6u+nhcRnxrieBtW57q16uv5EXFuRGzX0CYi4uMRcUPVZkFE/FdEjG861iurS333\nVvXdERHfGUnfS3UzeEgjsyHwyBDblwIbAC9p3BgRk4EDgI8z+sss3wGOAa6pvv93wGeAgaZ2CbwY\nOBv4FeWyzv9U5z8KOB1YRhl1OZJymeh1TcfYAfhR9f2fAB4AvhcROw5xrsaf74PAfwHzgU8BlwPn\nUy4rrVJE7ARcAKxf1fYJ4GfA7g1tomozuO+jwHnAVOAHTYf8TvWzXwQcBjwO/KK55ur9UP8tnrI9\nIj4LnAbcWp3zRGAv4PcRsXnT9z4D+CVwbVXvzcBxEfGmhuONqWo6Ari6ancSsDkr/935JvBlymW9\nQ4DvAu8FLoqIsdWxng1cDGwLfKnqmzOBXYb42aTuk5m+fPlazQu4jvKBEg3b1gfuBJYD72hqfyVw\nRvXn5wMrgE+M4Dwvq9r+V9P246vzvKZh25xq2z82tX0h8ATwo9Wca/D7d2/Y9ixKwDq+YdtrqnZ7\nVu/XAxZQgtF6De0+WNX+m9Wc99DqeE9fRZv9KQFit6btB1ffu2tTf321qd2ZVbsjG7Z9D7hjiHMd\nBSxveL9tde7DmtrtRAlyhzds+211nvc0/b2YD5zTsO0DVZ2HrOJn3qNqs1/T9jdU299dvX9bdc5X\n1P3/hS9fa/JyxEMama8Dfwd8txpWfwlwBrBVtX/jwYYR8QHg7ym/fY/WP1F+iz6xafs0yjyRtzRt\nn5OZv27a9o6q7edHcL6bMnP64JvMvI/yW/72q/ieVwJbUMLREw3bTwMWj+Ccg5er3lGNbAxlX0rQ\nuy0injn4onzQB0+O3LyF0l9fa/r+k1jzeTXvrL73R03n/gvwJ546avTXzDx78E1mPg5cxcp9+L+A\ne4GTV3HefSl9c2nTea8F/tpw3kVVfW+NCG8Q0DrH4CGNQGZ+gzKJdApwI2UEZDvKSASUDwYiYrOq\n3fGZOX8NTjU4OjK76fwLKR84z29q/5Q5C5QPvBWUD+7VuWuIbQ8CT19NjTlEjU8Ad4zgnD+kXJr5\nFrCwmjvxv5tCyA6U8HZv0+vW6txbVO22pfystzed49YR1DGcCZR/G2c3nfsvlEtbWzS1nzfEMZr7\n8IXArZn5lLkkDXYAxlfnaT7v0wbPm5m/B35MuXx2XzWn5cDmuS9StzItSyOUmUdExH9QPhAXZ+aN\nDRMib6u+fooy1H5ORAyGhMF5D0+vts2vfite5elGWNZQ805GY/kw29t2F05mPgrsGRGvo4xYvBnY\nj/Kb/hszMykf/H+kzK8Yqpa5a3LqYbaPbXo/hhJm3lx9bfbXpvet6sMxwELgPcN8772Df8jMd1Xz\niPYB3kSZC/KJiNg1M5eO8rxSRxk8pFHIzMXA9IZNbwDmZeYt1fvnUX7Tvan5W4HPAv8PeAVw/TCn\n+DPlA2gHGn5rj3Jr7vhq/+rcXh1jp1WcZ238mfLBuANl4itQFkujjAL9z0gOkpm/pVw6+b8R8Rng\n3ymXE35D+RleVrVZXS1jKCMKjWupvHiItg9S+rDZC5re3075+e7MzNlPbb5GbgcmR8TYzBwuqNxO\nmcA6PTMfW90BM/MqyiWdIyJiCuXuqXdTQojUtbzUIq2hiNiPMt+hcT7Gf1LmWLy94XUw5YPse9X7\noS6PDLqwavvxpu2fpISXX4ygtJ9WbY9cxRyKtXEN5bfvDzXNMfgAQ3+wryQihrqMcx3l596wen8O\nsE1E/MsQ379RPHn78i+r7zukqdlQdxPdDoyr5ucMHus5lP8mjX5CGek4apj6nzHU9tU4F3g25Q6U\n4ZxD+WXwyOYdUW6xHlf9eag+vq76uuEQ+6Su4oiHNAIR8Q+UD4RfAfcDuwEHUoLCVwfbZeb/0PQb\nf8Mllxsz84JVnSczr4+I04CDqw/o31NukzwA+El1fX+VMvP26hLQ54DLIuInwGPAq4C7M/Ozq/+J\nn+JvASYzn4iIz1Fup/1tRPyQMtLxAZ4612IoR0ZZE+QXlBGLLYEPU+ab/KFqcwbwLuDU6pLM5ZRL\nIjsC/xt4IzArM6+LiAHgI9UH8nTKqMELhzjvDyi3qv40Ir5KmTfxIcrI0sSGn++O6uf7YrXGxk+B\nhylzZ94OfAM4YQQ/Z6PTKf8NT4iIXSi3y25a1XpKZl6Qmf8dEd8ADo+Il1P+rj1OmdS8LyVc/QR4\nf0R8hHJ78e3AZsC/UCb2XjjKuqSOM3hII3M35RbV/0v5h34O5bLJiauZMDhoNGt5fJDygXIg5YNu\nAfAFnnqXynDrUpCZR0XEHcDHKJcwllIuu5w+ku8fYvtK7zPzW9XaFJ+iTLD9I2W+wbGrOOagn1Em\nqH6AcvvufZRLNkdn5sPV8TMi3kaZ43EApR+WUiavnsiTc2qojvMXynoXbwMupcwdWWnSZ2Y+EBFv\np4SGL1P+Gx5O+WCf2NT2yxExuIbH4AjEXMpaIc0P1lttH2bmiojYm3K57T2Uu1zupwSQPza0+3BE\nXAP8K+W/+ROUW7ZPp4QvKGH0VZR5MVtSAseVlFt6R3IpTqpVlHlcktRbqtVIj87MkdxWLKlDumKO\nR0Q8NyLOiIj7quV/r4vyUK7GNp+vlhheGhGXRMSEuuqVJElrpvbgUV2XvZxyDfpNlGu4n6TMQB9s\ncxhlUtbBwGRgCXCx961LkrRu6YY5HocDd2XmQQ3bmq9THgocm5k/B4iIAyj3u7+dMhNckpqtag6L\npJrUPuJBmZB2TUScExELI2JWRPwthFSzyreiTBgDIDMfokym2q3j1UpaJ2Tm2Mw8tu46JK2sG4LH\n9pRb6W6l3CJ3KvDVePLR3FtRfmtZ2PR9C3nyORmSJGkd0A2XWsYAV2XmEdX766oFfj5EuZd/1KoH\nK72Jchvao60oUpKkPrERZUXfizPz/lYfvBuCxz089WFWN1Puc4eyhkFQ7ldvHPXYkvLUxqG8ibJ8\nsCRJWjPvBc5ebatR6obgcTnwoqZtL6KaYJqZcyJiAWWFv+sBImJzymqOpwxzzDsBzjzzTHbcccc2\nlKyhTJ06lRNPbH6au9rJPu88+7zz7PPOuvnmm9l///2h+ixttW4IHicCl1cPiTqHEigOoiwBPOgk\n4HMRMZvSEcdSViX82TDHfBRgxx13ZOLEicM0UauNGzfO/u4w+7zz7PPOs89r05apCrUHj8y8JiLe\nARwHHEFZxvjQzPxBQ5vjq4dCfYPyEKrLgL0zc1kdNUuSpDVTe/AAyMwLWc3DjTLzaODoTtQjSZLa\noxtup5UkSX3C4KGWmTJlSt0l9B37vPPs886zz3tLTz6dtnrA3MyZM2c6IUmSpFGYNWsWkyZNApiU\nmbNafXxHPCRJUscYPCRJ6hIrVsAOO8DAQN2VtI/BQ5KkLnHLLTB7NmyxRd2VtI/BQ5KkLjFjBowZ\nA5Mn111J+xg8JEnqEtOnw0tfCpttVncl7WPwkCSpS0yfDrvvXncV7WXwkCSpCzzwQJnjsdtudVfS\nXgYPSZK6wBVXlK+OeEiSpLabMaPczbL99nVX0l4GD0mSusD06eUyS0TdlbSXwUOSpJo98QRceWXv\nX2YBg4ckSbW74QZYssTgIUmSOmD6dFhvPSjPZuttBg9Jkmo2YwZMnAgbb1x3Je1n8JAkqWb9sHDY\nIIOHJEk1WrgQ7rij9xcOG2TwkCSpRjNmlK+OeEiSpLabPh222aa8+oHBQ5KkGs2Y0T+jHWDwkCSp\nNsuWwdVXGzwkSVIHXHstPPZY/0wsBViv7gIkSepFd99d7lhZlfPOg402gpe/vDM1dQODhyRJLfbg\ng7DTTvDQQ6tv+/rXwwYbtL+mbmHwkCSpxb75TXj0Ufj972HTTVfddvvtO1NTtzB4SJLUQsuWwVe/\nCvvvD3vuWXc13cfJpZIktdAPfwjz58MnPlF3Jd3J4CFJUotkwrRpsPfe8Pd/X3c13cngIUlSi1x6\nKVx3HXzyk3VX0r0MHpIktci0abDzzuVOFQ3NyaWSJLXAjTfCRRfB6adDRN3VdC9HPCRJaoETToCt\nt4b99qu7ku5m8JAkaS0tWABnngmHHNJfi4GtCS+1SJLWaQsXlrtIRrJKaLv89a8lcBx8cH01rCsM\nHpKkddrXvga33QYf+1i9dey2G4wfX28N6wKDhyRpnbVkCZx6Khx0EHzpS3VXo5FwjockaZ112mmw\naBEcemjdlWikDB6SpHXS8uVw4onwznfCdtvVXY1GykstkqR10vnnw+zZ5W4SrTtqH/GIiKMiYkXT\n66aG/d8bYv+FddYsSarftGmwxx6wyy51V6LR6JYRjxuAvYDBtd6eaNr/S+DAhv2PdaYsSVI3uuIK\nuPxyOO+8uivRaHVL8HgiM+9dxf7HVrNfktRHpk2DCRNgn33qrkSjVfullsoOEXF3RNweEWdGxPOa\n9r82IhZGxC0R8fWIeEYtVUqSajdnDvzkJzB1KowdW3c1Gq1uGPG4gnIZ5VbgOcDRwGUR8feZuYRy\nmeVcYA7wQuBLwIURsVtmZi0VS5JG5Z574OtfhyeaL6SvgauuKgt1HXjg2h9LnVd78MjMixve3hAR\nVwF/Bt4FfC8zz2nYf2NE/BG4HXgt8NtVHXvq1KmMGzdupW1TpkxhypQprShdkjRC3/oWHHccPP/5\nrTneMcfAJpu05lj9bGBggIGBgZW2LV68uK3njG4cNKjCxyWZ+dlh9v8F+GxmfmuY/ROBmTNnzmTi\nxIltrFSSNBJ7710eFX+h9yR2vVmzZjFp0iSASZk5q9XH75Y5Hn8TEZsCE4B7htm/DfDM4fZLkrrL\nihUwYwbsvnvdlagb1B48IuIrEbFnRDw/InYHzgMeBwYi4mkRcXxE7FLt3wv4KXAbcPGqjitJ6g63\n3AKLF5eHqEm1z/EAtgHOpoxi3Av8Adg1M++PiI2AlwEHAOOB+ZTAcWRmPl5TvZKkUZg+HcaMgcmT\n665E3aD24JGZw870zMxHgTd3sBxJUotNnw4vexlstlndlagb1H6pRZLU22bM8DKLnmTwkCS1zQMP\nlDkeTizVIIOHJKltrriifHXEQ4MMHpKktpk+HbbYArbfvu5K1C0MHpKktpk+vYx2RKy+rfqDwUOS\n1BZPPFGeq+L8DjUyeEiS2uKPf4QlSwweWpnBQ5LUFjNmwHrrQXnsh1QYPCRJbTF9OkycCBtvXHcl\n6iYGD0lSW7hwmIZi8JAktdyCBXDHHc7v0FMZPCRJLTdjRvlq8FAzg4ckqeVmzIBttikvqZHBQ5LU\nctOnO9qhoa1XdwGSpHXbkUfC2WevvG3OHJg2rZ561N0MHpKkNbZgAXz5y/DmN8NOOz25ff31Yf/9\n66tL3cvgIUlaYyefDBtsAKedBuPH112N1gXO8ZAkrZElS+DUU+GDHzR0aOQMHpKkNXLaabBoERx6\naN2VaF1i8JAkjdry5XDiibDvvrDddnVXo3WJczwkSaN2wQUwezacdVbdlWhd44iHJGnU/uM/YI89\nYPLkuivRusYRD0nSqFx5JVx+OZx3Xt2VaF3kiIckaVSmTYMJE2CffequROsiRzwkScM69VS4664n\n3y9fDueeC1/7GowdW19dWncZPCRJQ7rySvjIR2DbbctKpIN23RXe//766tK6zeAhSRrStGmwww5w\nyy0wxgvzahGDhyTpKebMKZdUTj7Z0KHW8q+TJOkpTjoJnv50L6mo9QwekqSVPPggfOc78OEPwyab\n1F2Neo3BQ5K0km9+Ex5/HP7t3+quRL3I4CFJ+ptly+CrX4X3vQ+22qruatSLDB6SpL/54Q9h/nz4\nxCfqrkS9yuAhSQIgszyDZe+9Yaed6q5GvcrbaSWJMqFyzpy6q6jX9deX1wkn1F2JepnBQ1Lfy4S9\n9oJrr627kvpNnAivf33dVaiXGTwk9b1LLy2h4/vfh5e+tO5q6rXddhBRdxXqZQYPSX1v2jTYeWc4\n4AA/dKV2M3hI6ms33ggXXQRnnGHokDrBu1ok9bUTToCtt4b99qu7Eqk/1B48IuKoiFjR9Lqpqc3n\nI2J+RCyNiEsiYkJd9UrqHQsWwJlnwiGHrPzYd0ntU3vwqNwAbAlsVb32GNwREYcBHwUOBiYDS4CL\nI2KDGuqU1ENOPhk22AAOPrjuSqT+0S1zPJ7IzHuH2XcocGxm/hwgIg4AFgJvB87pUH2SesySJXDq\nqfDBD8L48XVXI/WPbhnx2CEi7o6I2yPizIh4HkBEbEcZAbl0sGFmPgRcCexWT6mSesFpp8GiRfDx\nj9ddidRfuiF4XAEcCLwJ+BCwHfDfEfE0SuhIyghHo4XVPkkateXL4cQTYd994QUvqLsaqb/Ufqkl\nMy9ueHtDRFwF/Bl4F3BLPVWpHRYuLM+AeOihuitRv3v8cbjrLjjrrLorkfpP7cGjWWYujojbgAnA\n74CgTDxtHPXYEljt4sZTp05l3LhxK22bMmUKU6ZMaVm9GrmvfQ1uuw0+9rG6K5Fg221h8uS6q5Dq\nNTAwwMDAwErbFi9e3NZzRma29QSjFRGbAncBR2TmKRExH/hKZp5Y7d+cEkIOyMwfDXOMicDMmTNn\nMnHixE6VrlVYsqT8Q/++98FJJ9VdjSRpOLNmzWLSpEkAkzJzVquPX/uIR0R8BbiAcnlla+AY4HHg\nB1WTk4DPRcRs4E7gWGAe8LOOF6s1NjiR79BD665EklSn2oMHsA1wNvBM4F7gD8CumXk/QGYeHxGb\nAN8AxgOXAXtn5rKa6tUoDU7ke+c7ywOoJEn9q/bgkZmrnXCRmUcDR7e9GLXF+efD7NllhUhJUn/r\nhttp1eOmTYM99oBddqm7EklS3Wof8VBvu+IKuPxyOO+8uiuRJHUDRzzUVtOmwYQJsM8+dVciSeoG\njniobebMgZ/8pKzfMXZs3dVIkrqBwaNG11wD555bdxXtc9VV5eFbBx5YdyWSpG5h8KhJZnkq5l13\nwTOfWXc17XPMMbDJJnVXIUnqFgaPmlx6KVx/Pfz617DXXnVXI0lSZzi5tCbTpsHOO8PrX193JZIk\ndY4jHjW44Qa46CI4/XSIqLsaSZI6xxGPGpxwAmy9Ney3X92VSJLUWQaPDluwAM46Cw45BDbYoO5q\nJEnqLINHh518cgkcBx9cdyWSJHWewaODliyBU08tt9GOH193NZIkdZ7Bo4O+/31YtAg+/vG6K5Ek\nqR7e1dICjz4KN920+nYnnQT77gsveEHbS5IkqSsZPFrgYx+Db397ZG3PPru9tUiS1M0MHmtpwYKy\nHsdhh8G73rXqtpttBjvs0Jm6JEnqRgaPtTR4l8rhhzthVJKk1XFy6VoYvEvloIMMHZIkjYTBYy2c\ndlq5S+XQQ+uuRJKkdYPBYw0tX16WPvcuFUmSRs45Hmvo/PPh9tu9S0WSpNFwxGMNTZsGe+wBkyfX\nXYkkSesORzzWwJVXwuWXw09/WnclkiStWxzxWAPTppX1OPbZp+5KJElatzji0eD88+GTn4TMVbe7\n4w445RQYY2yTJGlUDB4NLrkE/vpXOPDAVbfbZBP4wAc6UpIkST3F4NFg7lx4xSvgS1+quxJJknqT\nFwsazJ0Lz3te3VVIktS7DB4NDB6SJLWXwaPy6KNw770GD0mS2sngUbn77vJ1m23qrUOSpF5m8KjM\nnVu+OuIhSVL7rFXwiIjNIuIrEXF1RMyKiK9FxLNaVVwnDQYPRzwkSWqftR3x+BbwLOAo4Bhge+Cs\ntS2qDnPnwjOfWdbokCRJ7TGqdTwiYipwUubf1vZ8FfB3mbm82n8rcEVrS+wM72iRJKn9RruA2AuB\nKyPiXzPzWuAS4BcR8VNgfeB9wMUtrrEj5s71MoskSe02quCRmR+NiF2B70bEb4HPAPsDbwDGAj8C\nTm55lR0wbx7svnvdVUiS1NtGvWR6Zl4REa8CDgNmAJ/KzHe2vLIO81KLJEntt0aTSzPzicz8ArAP\n8PGI+HFEbNXa0jpn6VJ44AGDhyRJ7Taq4BERO1e3zj4cEZcDYzJzL+AXwPSI+HBbqmwz1/CQJKkz\nRjvi8V3gMsrdLD8C/gsgM78H7AK8OiJmrE1BEXF4RKyIiBMatn2v2tb4unBtztPINTwkSeqM0c7x\n+Dtgv8ycHRF/Aj4+uCMz7wX2j4g3rmkx1dyRg4Hrhtj9S+BAIKr3j63peZrNm1e+GjwkSWqv0Y54\n/A74ZkQcTFko7PLmBpn5qzUpJCI2Bc4EDgIWDdHkscy8NzP/Ur0Wr8l5hjJ3LmyxBWy4YauOKEmS\nhjLa4HEAcC3wNuAOoJVzOk4BLsjM3wyz/7URsTAibomIr0fEM1p1Yu9okSSpM0a7jseDwCdbXURE\nvBt4OfDKYZr8EjgXmENZxOxLwIURsVvDKqprzOAhSVJnjPaulh0iYiAiNh9i37iIODsiXjzKY24D\nnAS8NzMfH6pNZp6TmT/PzBsz83zgn4HJwGtHc67huGqpJEmdMdrJpZ8C5mbmQ807MnNxRMwFDqdM\nAh2pScCzgVkRMThxdCywZ0R8FNiweVQjM+dExH3ABOC3wx146tSpjBs3bqVtU6ZMYcqUKSttmzfP\nEQ9JUv8ZGBhgYGBgpW2LF7dsCuWQYjRXKqqHwO2fmVcPs38ScHZmvmgUx3wa8Pymzd8HbgaOy8yb\nh/iebYA/A2/LzJ8PsX8iMHPmzJlMnDhxled/+GHYfHM4+2xoyiOSJPWdWbNmMWnSJIBJmTmr1ccf\n7YjHtsBfVrH/PmBUYweZuQS4qXFbRCwB7s/Mm6tgchRljscCyijHl4HbaMED6Vw8TJKkzhntXS2L\nKZM7hzMBeMplmDXQOAyzHHgZ8DPgVuBbwNXAnsPNCRkNg4ckSZ0z2hGP/wY+Bgx3y+shlJVN10pm\nvr7hz48Cb17bYw5n7lyIgOc+t11nkCRJg0YbPL4EzIiIHwPHU0YgAF4MfBp4E7BOPVx+7lzYaitY\nf/26K5EkqfeNdh2PayNiX8ozW97RsCso8zve1Y6JKO3kHS2SJHXOaEc8yMyfR8TzKZc/JlBCx23A\nrzJzaYvrazsXD5MkqXNGu4DYxhHxz5n5SGaeBzwD2ArYE/j3iPhKRGzUjkLbxeAhSVLnjHbE4/3A\nW4DBtTM+CtwIPFK9fzEwHzixJdW1WabBQ5KkThrt7bTvBb7ZtO09mfm6zHwdZWXTd7Wksg5YtAiW\nLHG5dEmSOmW0wWMC8MeG948CKxreXwXstLZFdcq8eeWrIx6SJHXGaC+1jAc2HHyTmc9u2j+mcX+3\nc/EwSZI6a7QjHvOAl6xi/8uqNuuEuXNh7Fh4znPqrkSSpP4w2uBxIfD5oe5ciYiNKc9U+UUrCuuE\nuXPLiqVjx9ZdiSRJ/WG0l1q+SJk8emtEnExZvwPgRZQ7XNar2qwT5s51YqkkSZ002pVLF0bE7sCp\nwHGUxcOgPNTtEuAjmbmwtSW2j6uWSpLUWWuycukc4M0R8QzKXS4AszPzgZZW1gFz58IrXlF3FZIk\n9Y9RB49BVdC4qoW1dJSLh0mS1HmjnVzaM+6/Hx591OAhSVIn9W3wGFzDw8mlkiR1Tt8HD0c8JEnq\nnL4NHvPmwfrrw5Zb1l2JJEn9o2+Dx9y5sPXWMKZve0CSpM7r249d72iRJKnz+jp4OLFUkqTO6uvg\n4YiHJEmd1ZfBY8UKuPtug4ckSZ3Wl8Hj3nth2TKDhyRJndaXwcPFwyRJqkdfBw9HPCRJ6qy+DR4b\nbgjPfnbdlUiS1F/6MnjMm1cus0TUXYkkSf2lL4OHt9JKklSPvg0eTiyVJKnz+jZ4OOIhSVLn9V3w\nWL7cxcMkSapL3wWPhQtL+DB4SJLUeX0XPFw8TJKk+vRt8HDEQ5KkzuvL4LHxxvCMZ9RdiSRJ/acv\ng8fznufiYZIk1aHvgse8eV5mkSSpLn0XPFw8TJKk+vRl8HDEQ5KkevRV8HjiCbjnHoOHJEl16brg\nERGHR8SKiDihafvnI2J+RCyNiEsiYsJojz1/PqxYYfCQJKkuXRU8IuJVwMHAdU3bDwM+Wu2bDCwB\nLo6IDUZz/HnzylfneEiSVI+uCR4RsSlwJnAQsKhp96HAsZn588y8ATgAeC7w9tGcw8XDJEmqV9cE\nD+AU4ILM/E3jxojYDtgKuHRwW2Y+BFwJ7DaaE8ydC5tuCuPGtaBaSZI0auvVXQBARLwbeDnwyiF2\nbwUksLBp+8Jq34i5eJgkSfWqPXhExDbAScA/ZubjrTz21KlTGdcwvHH11fDsZ08BprTyNJIkrZMG\nBgYYGBjdOuAeAAAPeklEQVRYadvixYvbes7IzLaeYLUFRLwN+AmwHBgcixhLGeVYDrwYmA28PDOv\nb/i+3wHXZubUIY45EZg5c+ZMJk6c+LftkyfDS18K3/lOm34YSZLWcbNmzWLSpEkAkzJzVquP3w1z\nPH4NvJRyqWXn6nUNZaLpzpl5B7AA2GvwGyJic2AXYPpoTuTiYZIk1av2Sy2ZuQS4qXFbRCwB7s/M\nm6tNJwGfi4jZwJ3AscA84GcjPc+yZbBwocFDkqQ61R48hrHS9Z/MPD4iNgG+AYwHLgP2zsxlIz3g\n3XdDpsFDkqQ6dWXwyMzXD7HtaODoNT3m4BoeLh4mSVJ9umGOR0cMrlrqiIckSfXpm+Axd25ZOGyz\nzequRJKk/tVXwcPRDkmS6mXwkCRJHdM3wePuu2HrreuuQpKk/tY3wePBB+GZz6y7CkmS+ltfBY/x\n4+uuQpKk/tYXwWPFCli8GJ7+9LorkSSpv/VF8Hj44RI+HPGQJKlefRE8Fi0qXx3xkCSpXn0VPBzx\nkCSpXn0RPB58sHw1eEiSVK++CB5eapEkqTv0RfBwxEOSpO7QF8Fj0SJ42tNg/fXrrkSSpP7WF8HD\nxcMkSeoOfRE8Fi1yfockSd2gL4KHIx6SJHWHvggejnhIktQd+iJ4OOIhSVJ36Ivg4YiHJEndoW+C\nhyMekiTVry+Cx4MPOuIhSVI36PngsWwZLF3qiIckSd2g54OHz2mRJKl79E3wcMRDkqT69Xzw8AFx\nkiR1j54PHl5qkSSpe/R88HDEQ5Kk7tHzwWPRIhgzBjbbrO5KJElSzwePweXSI+quRJIk9XzwcLl0\nSZK6R18ED+d3SJLUHXo+eLhcuiRJ3aPng4cjHpIkdY+eDx6OeEiS1D16Png44iFJUvfo+eDhiIck\nSd2jp4NHpiMekiR1k54OHkuXwvLlBg9JkrpF7cEjIj4UEddFxOLqNT0i3tyw/3sRsaLpdeFIjv3w\nw+Wrl1okSeoO69VdADAXOAz4ExDAgcDPIuLlmXlz1eaX1fbBhc8fG8mBB4OHIx6SJHWH2oNHZv6i\nadPnIuLDwK7AYPB4LDPvHe2xHfGQJKm71H6ppVFEjImIdwObANMbdr02IhZGxC0R8fWIeMZIjueI\nhyRJ3aX2EQ+AiHgJMAPYCHgYeEdm3lrt/iVwLjAHeCHwJeDCiNgtM3NVx33oofLV4CFJUnfoiuAB\n3ALsDIwD9gVOj4g9M/OWzDynod2NEfFH4HbgtcBvV3XQhx+GjTeGDTdsU9WSJGlUuiJ4ZOYTwB3V\n22sjYjJwKPDhIdrOiYj7gAmsJnj86EdTWbFiHG9965PbpkyZwpQpU1pVuiRJ66yBgQEGBgZW2rZ4\n8eK2njNWc7WiFhFxKfDnzPw/Q+zbBvgz8LbM/Pkw3z8RmDllykyuu24iN97Y3nolSeoVs2bNYtKk\nSQCTMnNWq49f+4hHRHyRMo/jLmAz4L3Aa4A3RsTTgKMoczwWUEY5vgzcBly8umM/9JB3tEiS1E1q\nDx7AFsBpwHOAxcD1wBsz8zcRsRHwMuAAYDwwnxI4jszMx1d34IcfdmKpJEndpPbgkZkHrWLfo8Cb\nh9u/Og8/DNtuu6bfLUmSWq2r1vFoNUc8JEnqLj0fPJzjIUlS9+jp4PHQQ454SJLUTXo6eDzyiMFD\nkqRu0tPBA7zUIklSN+n54OGIhyRJ3aPng4cjHpIkdY+eDx6OeEiS1D16Png44iFJUvfo+eCx2WZ1\nVyBJkgb1dPDYbDMY09M/oSRJ65ae/lh2tEOSpO7S08Fj883rrkCSJDXq6eDhiIckSd3F4CFJkjrG\n4CFJkjrG4CFJkjqmp4OHk0slSeouPR08HPGQJKm7GDwkSVLHGDwkSVLH9HTwcI6HJEndpaeDhyMe\nkiR1F4OHJEnqGIOHJEnqmJ4OHhtuWHcFkiSpUU8HD0mS1F0MHpIkqWMMHpIkqWMMHpIkqWMMHpIk\nqWMMHpIkqWMMHpIkqWMMHpIkqWMMHpIkqWMMHpIkqWMMHpIkqWMMHpIkqWMMHpIkqWMMHpIkqWMM\nHpIkqWNqDx4R8aGIuC4iFlev6RHx5qY2n4+I+RGxNCIuiYgJddWr4Q0MDNRdQt+xzzvPPu88+7y3\n1B48gLnAYcBEYBLwG+BnEbEjQEQcBnwUOBiYDCwBLo6IDeopV8PxH4fOs887zz7vPPu8t9QePDLz\nF5l5UWbenpmzM/NzwF+BXasmhwLHZubPM/MG4ADgucDbaypZkiStodqDR6OIGBMR7wY2AaZHxHbA\nVsClg20y8yHgSmC3eqqUJElrar26CwCIiJcAM4CNgIeBd2TmrRGxG5DAwqZvWUgJJJIkaR3SFcED\nuAXYGRgH7AucHhF7rsXxNgK4+eabW1CaRmrx4sXMmjWr7jL6in3eefZ559nnndXw2blRO44fmdmO\n466ViLgEmA0cD9wOvDwzr2/Y/zvg2sycOsz3vwc4qwOlSpLUq96bmWe3+qDdMuLRbAywYWbOiYgF\nwF7A9QARsTmwC3DKKr7/YuC9wJ3Ao+0tVZKknrIR8ALKZ2nL1R48IuKLwC+Bu4DNKIHhNcAbqyYn\nAZ+LiNmUIHEsMA/42XDHzMz7gZanNEmS+sT0dh249uABbAGcBjwHWEwZ2XhjZv4GIDOPj4hNgG8A\n44HLgL0zc1lN9UqSpDXUlXM8JElSb+qqdTwkSVJvM3hIkqSO6cngERH/FhFzIuKRiLgiIl5Vd029\nICI+ExFXRcRDEbEwIs6LiL8bop0P9WuTiDg8IlZExAlN2+3zFoqI50bEGRFxX9Wn10XExKY29nmL\nVKtWHxsRd1T9OTsiPjdEO/t8LUTEP0TE+RFxd/XvyFuHaLPKPo6IDSPilOr/jYcj4scRscVo6ui5\n4BER+wHTgKOAVwDXUR4q96xaC+sN/wB8jXI78z8C6wO/ioiNBxv4UL/2qQL0wZS/043b7fMWiojx\nwOXAY8CbgB2BTwIPNrSxz1vrcOBfgY8ALwY+DXw6Ij462MA+b4mnAf9D6eenTPAcYR+fBLwFeCew\nJ+XZaeeOqorM7KkXcAXwnw3vg3L77afrrq3XXsCzgBXAHg3b5gNTG95vDjwCvKvuetflF7ApcCvw\neuC3wAn2edv6+jjg96tpY5+3ts8vAL7VtO3HwOn2edv6fAXw1qZtq+zj6v1jlMeaDLZ5UXWsySM9\nd0+NeETE+sAkVn6oXAK/xofKtcN4Smp+AMCH+rXVKcAFWd1mPsg+b4t9gGsi4pzqkuKsiDhocKd9\n3hbTgb0iYgeAiNgZeDVwYfXePm+zEfbxKynLcDS2uZWyDteI/zt0wzoerfQsYCxDP1TuRZ0vp3dF\nRFCG3P6QmTdVm7fCh/q1XPXE5pdT/qdvZp+33vbAhymXbL9AGXL+akQ8lplnYJ+3w3GU36ZviYjl\nlGkAn83MH1T77fP2G0kfbwksqwLJcG1Wq9eChzrn68BOlN9K1CYRsQ0l4P1jZj5edz19YgxwVWYe\nUb2/rnqC9oeAM+orq6ftB7wHeDdwEyVo/2dEzK/CnnpIT11qAe4DllNSWaMtgQWdL6c3RcTJwD8B\nr83Mexp2LaDMqbH/W2cS8GxgVkQ8HhGPUx4pcGhELKP8pmGft9Y9QPOjrW8Gtq3+7N/z1jseOC4z\nf5SZN2bmWcCJwGeq/fZ5+42kjxcAG1TPTBuuzWr1VPCofiOcSXmoHPC3SwJ70cZ15/tJFTreBrwu\nM+9q3JeZcyh/+Rr7f/Chfvb/mvk18FLKb4A7V69rgDOBnTPzDuzzVrucp16afRHwZ/DveZtsQvml\nsdEKqs8o+7z9RtjHM4Enmtq8iBLKZ4z0XL14qeUE4PsRMRO4CphK+Uv9/TqL6gUR8XVgCvBWYElE\nDCbjxZk5+BTgUT/UT8PLzCWUoee/iYglwP2ZOfhbuX3eWicCl0fEZ4BzKP/wHgT8S0Mb+7y1LqD0\n5zzgRmAi5d/ubze0sc/XUkQ8DZhAGdkA2L6ayPtAZs5lNX2cmQ9FxHeAEyLiQeBh4KvA5Zl51YgL\nqfuWnjbdJvSRqtMeoaSwV9ZdUy+8KL+BLB/idUBTu6Mpt2UtpTxWeULdtffSC/gNDbfT2udt6eN/\nojywcinlg/D/DNHGPm9dfz+N8kvjHMraEX8CjgHWs89b2s+vGebf8e+OtI+BDSnrOd1XBY8fAVuM\npg4fEidJkjqmp+Z4SJKk7mbwkCRJHWPwkCRJHWPwkCRJHWPwkCRJHWPwkCRJHWPwkCRJHWPwkCRJ\nHWPwkCRJHWPwkDRiEbFlRPxnRPwpIh6JiHsi4rKI+FBEbFx3fZK6Xy8+JE5SG0TEdpSnVD4AHA7c\nADxGeXruwZSHSf28tgIlrRMc8ZA0UqcCy4BJmXluZt6amXdm5gWZuU9m/hwgIsZFxLcj4i8RsTgi\nfh0RLxs8SEQcFRHXRsT+ETEnIhZFxED15MzBNhERn4mIOyJiadX+nQ37x0fEWdU5lkbErRHx/k52\nhqQ1Y/CQtFoR8QzgDcDJmfnoapr/GHgm8CbK481nAb+OiPENbV4IvI3yFNi3UJ6aeXjD/v8H7E8Z\nSdmJ8qj6MyLiH6r9/w68uDrHi4EPU56WKanLealF0khMAAK4rXFjRNwLbFS9PZlyqeWVlMdkP15t\n/3REvAPYF/j24LcC78/MpdVxzgD2Ao6IiA2AzwB7ZeaVVfs7q9Dxr8BlwPOAazPz2mr/Xa38YSW1\nj8FD0tp4FWXk9GxgQ2BnYDPggYhobLcRZZRj0J2DoaNyD7BF9ecJwCbAJbHyQdanjJ5AuexzbkRM\nAn4F/DQzZ7TkJ5LUVgYPSSMxG0jgRY0bM/NOgIh4pNq0KTCfculkpeQBLGr48+NN+5InL/1uWn39\np+pYjR6rzntRRGxbtXkD5VLOKZn56ZH/SJLqYPCQtFqZ+UBEXAJ8NCK+lpmPDNN0FrAVsDwz1/Ty\nx02UgPH8zPzDKmq6HziDMvfjD8DxgMFD6nIGD0kj9RHgD8A1EXEMcD2wAphMmeB5dWb+OiKuAH4a\nEYdR5oRsTRmZ+Elmzhr60E/KzL9GxH8AJ0bE2Oqc44BXA4sz84zq/DOBGymXcf6ZElgkdTmDh6QR\nycw7IuIVlDtOvghsQxmZuIky2nBq1XRv4AvAd4FnAwuA/wYWjuJcR0TEXyh3umxPuUwzqzovlNt6\nvwi8AHiEMuF0ypr/dJI6JTKz7hokSVKfcB0PSZLUMQYPSZLUMQYPSZLUMQYPSZLUMQYPSZLUMQYP\nSZLUMQYPSZLUMQYPSZLUMQYPSZLUMQYPSZLUMQYPSZLUMQYPSZLUMf8f/7Vz4CvCDDoAAAAASUVO\nRK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10cc67850>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(sorted(gc_contents))\n",
    "plt.xlabel('Genes')\n",
    "plt.ylabel('GC%')\n",
    "plt.title(str(len(gc_contents)) + ' orchid sequences')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x10cc67550>"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh4AAAGHCAYAAAD/QltcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAAPYQAAD2EBqD+naQAAIABJREFUeJzt3XmYHVWB///3J2wRlKAiMI7GDQbjODomCOI+oqL4G5VZ\n0NYMg858GdfRuIz6GwUU9xkNisv4dRRFxjg4buiAiIq4oKIGXCAGDcHIFmjRuMSwmPP941Trzc1N\np7tTXbe78349z33St+rcU+eervT93FOnqlJKQZIkqQvzht0ASZK08zB4SJKkzhg8JElSZwwekiSp\nMwYPSZLUGYOHJEnqjMFDkiR1xuAhSZI6Y/CQJEmdMXhIO6kkVyY5awLlHpFkc5KHT6Dsl5J8sZ0W\nSpqLDB7SBCVZkuSzSTYk+WWSc5Pcfzuv2TXJZc0H94u6ausETeZ+CRMt6z0YJI1r12E3QJoNkiwG\nvgKsA04EdgGeA3wpyaGllB9t46X/DNyVWfyBXEq5IMltSik3D7stkmY/RzykiTkZ2Ag8qJRySinl\nLcBDqAHk9YNekGQ/4FXAG4F00cgk86ejXkOHpLYYPKSJeSjw+VLKL8YWlFKuAy4A/r8kew54zRuB\nVcB/TWZDSXZJ8qokP06yKcnaJK9LsntfuSuTnJXksUm+leS3wPE965cm+WaS3yS5MckFSR4zYHsP\nacr9NsmaJH/Xt37gHI8kxzdt3JjkG0keOon3+JgkX0ny8yS/SvLDJK/rK7N7klcn+VHTD+uSvGlA\nP+yeZHmS65tDYJ9M8sdNm0/oKfeBJGsHtOWkJJsHLF+a5NvN+/tZkhVJ7tJX5ktJvpdkUZLzm76+\nKslLB9S3R7Ot1U1fX5PkY0nu0VMmSV6Y5AdNmeuS/EeSffrqOqQ51HdD074rkrxvIn0vDZvBQ5qY\nPYDfDli+EdgduG/vwiSHAscCL2Tyh1neB7wa+Hbz+i8BrwBW9JUrwL2BDwOfox7WuaTZ/onA6cDN\n1FGXE6iHif6ir46DgI82r38RcCNwWpJFA7bV+/7+AfgP4BrgpcDXgLOoh5XGleQ+wKeB3Zq2vQj4\nFPDgnjJpyoytex7wCWAZ8JG+Kt/XvPfPAi8DbgH+t7/NzfNBv4utlif5V+CDwOpmm8uBI4ALkuzd\n99o7AOcAFzftXQW8McmRPfXNa9r0KuBbTblTgL3Zct/5v8CbqIf1/hl4P/B04LNJdmnquhNwLrAQ\neEPTN2cAhw14b9LMU0rx4cPHdh7Ad6kfKOlZthtwJfA74Oi+8t8EPtT8fDdgM/CiCWznfk3Z/+hb\n/uZmO4/oWba2WfbovrL3Am4FPrqdbY29/sE9y/alBqw39yx7RFPu4c3zXYHrqMFo155y/9C0/Yvb\n2e4LmvpuP06ZpdQAcXjf8uOb1z6or7/e3lfujKbcCT3LTgOuGLCtE4Hf9Txf2Gz7ZX3l7kMNci/v\nWXZ+s52n9e0X1wBn9ix7RtPOfx7nPT+0KfOUvuWPaZY/tXn+pGabDxj2/wsfPqbycMRDmph3AX8C\nvL8ZVr8v8CHggGb9bcYKJnkG8KfUb9+TdRT1W/TyvuVvoc4TeULf8rWllM/3LTu6KfuaCWzvslLK\nhWNPSimj1G/59xznNYcA+1HD0a09yz8IbJjANscOVx3djGwM8jfUoHd5kjuOPagf9OEPIzdPoPbX\nqX2vP4Wpz6v56+a1H+3b9vXAj9h61OjXpZQPjz0ppdwCXMSWffhXwA3AO8bZ7t9Q++YLfdu9GPh1\nz3Z/0bTviUk8QUCzjsFDmoBSynuok0hHgEupIyD3oI5EQP1gIMntmnJvLqVcM4VNjY2O/Lhv++up\nHzh36yu/1ZwF6gfeZuoH9/asG7Ds58Dtt9PGMqCNtwJXTGCb/009NPNeYH0zd+Jv+0LIQdTwdkPf\nY3Wz7f2acgup73VN3zZWT6Ad23Ig9W/jj/u2fT310NZ+feWvGlBHfx/eC1hdStlqLkmPg4B9mu30\nb3evse2WUi4A/od6+Gy0mdNyXP/cF2mmMi1LE1RKeVWSf6d+IG4opVzaMyHy8ubfl1KH2s9MMhYS\nxuY93L5Zdk3zrXjczU2wWYPmnUzG77axfNrOwimlbAIenuQvqCMWjwOeQv2m/9hSSqF+8H+fOr9i\nUFt+OpVNb2P5Ln3P51HDzOOaf/v9uu95W304D1gPPG0br71h7IdSyjHNPKK/BI6kzgV5UZIHlVI2\nTnK7UqcMHtIklFI2ABf2LHoMcFUp5YfN87tSv+le1v9S4F+B/x94APC9bWziJ9QPoIPo+daeemru\nPs367VnT1HGfcbazI35C/WA8iDrxFagXS6OOAl0ykUpKKedTD528JMkrgNdSDyd8kfoe7teU2V5b\n5lFHFHqvpXLvAWV/Tu3Dfnfve76G+v6uLKX8eOviU7IGODTJLqWUbQWVNdQJrBeWUm7aXoWllIuo\nh3RelWSEevbUU6khRJqxPNQiTVGSp1DnO/TOx3gbdY7Fk3sex1M/yE5rng86PDLm7KbsC/uWv5ga\nXv53Ak37ZFP2hHHmUOyIb1O/fT+rb47BMxj8wb6FJIMO43yX+r73aJ6fCdwlyf8Z8Pr5+cPpy+c0\nr/vnvmKDziZaAyxo5ueM1fVH1N9Jr49TRzpO3Eb77zBo+XZ8DLgT9QyUbTmT+mXwhP4VqadYL2h+\nHtTH323+3WPAOmlGccRDmoAkD6N+IHwO+BlwOHAcNSi8faxcKeUS+r7x9xxyubSU8unxtlNK+V6S\nDwLHNx/QF1BPkzwW+HhzfH9cpZQ1zSGgVwJfSfJx4CbggcDVpZR/3f473srvA0wp5dYkr6SeTnt+\nkv+mjnQ8g63nWgxyQuo1Qf6XOmKxP/Bs6nyTrzZlPgQcA7y7OSTzNeohkUXA3wKPBVaWUr6bZAXw\nnOYD+ULqqMG9Bmz3I9RTVT+Z5O3UeRPPoo4sLe55f1c07+/1zTU2Pgn8ijp35snAe4C3TuB99jqd\n+jt8a5LDqKfL3rZp6ztLKZ8upXw5yXuAlyf5c+q+dgt1UvPfUMPVx4G/T/Ic6unFa4DbAf+HOrH3\n7Em2S+qcwUOamKupp6i+hPqHfi31sMny7UwYHDOZa3n8A/UD5TjqB911wOvY+iyVbV2XglLKiUmu\nAJ5PPYSxkXrY5fSJvH7A8i2el1Le21yb4qXUCbbfp843OHmcOsd8ijpB9RnU03dHqYdsTiql/Kqp\nvyR5EnWOx7HUfthInby6nD/MqaGp53rq9S6eBHyBOndki0mfpZQbkzyZGhreRP0dvpz6wb64r+yb\nkoxdw2NsBOKn1GuF9N9Yb7t9WErZnOTx1MNtT6Oe5fIzagD5fk+5Zyf5NvBP1N/5rdRTtk+nhi+o\nYfSB1Hkx+1MDxzepp/RO5FCcNFSp87gkaW5prkZ6UillIqcVS+rI0Od4JHlWku+m3vFzQ5ILkzyu\nr8xrmssLb0xyXpIDh9VeSZI0dUMPHtThy5dRhzqXUGe0f2rsks1JXkadkHU8cCjwG+Bcz1mXJGn2\nmZGHWpL8DHhJKeW0JNcA/1ZKWd6s25t6rvvfl1LOHGY7Jc1cSX5HPdRy8rDbIukPZtTk0may2jHA\nnsCFzYzyA6iTxQAopfwyyTepZxUYPCQNVErpvzCYpBlgRgSP5rz6rwPzqaetHV1KWZ3kcOrM8PV9\nL1nPH+6RIUmSZokZETyAHwL3BxZQz1c/vTnPf0qaGysdST0NbVMbDZQkaScxn3pF33NLKT9ru/IZ\nETz6bi51cXMPghdQrw8Q6rnqvaMe+1Pv2LgtR1IvHyxJkqbm6cCHt1tqkmZE8BhgHrBHKWVtkuuo\nV/f7Hvx+culhwDvHef2VAGeccQaLFi2a5qZqzLJly1i+vP9u7ppO9nn37PPu2efdWrVqFUuXLoXm\ns7RtQw8eSV5Pvd/COuoVIZ8OPIJ6SWSAU4BXJvkxtRNOpl6R8FPjVLsJYNGiRSxevHicYmrTggUL\n7O+O2efds8+7Z58PzbRMVRh68AD2Az4I/BH10r/fAx5bSvkiQCnlzc0Nod5DvQHVV4DHl1JuHlJ7\nJUnSFA09eJRS/nECZU4CTpr2xkiSpGk1E65cKkmSdhIGD7VmZGRk2E3Y6djn3bPPu2efzy0z8pLp\nOyrJYuA73/nOd5yQJEnSJKxcuZIlS5YALCmlrGy7fkc8JElSZwwekiSpMwYPSZLUGYOHJEnqjMFD\nkiR1xuAhSZI6Y/CQJEmdMXhIkqTOGDwkSVJnDB6SJKkzBg9JktSZXYfdAEnS7LJu3TpGR0dbq2/f\nffdl4cKFrdWnmc3gIUmasHXr1nHwwYvYtGlja3XOn78nq1evMnzsJAwekqQJGx0dbULHGcCiFmpc\nxaZNSxkdHTV47CQMHpKkKVgELB52IzQLOblUkiR1xuAhSZI6Y/CQJEmdMXhIkqTOGDwkSVJnDB6S\nJKkzBg9JktQZg4ckSeqMwUOSJHXG4CFJkjpj8JAkSZ0xeEiSpM4YPCRJUmcMHpIkqTMGD0mS1BmD\nhyRJ6ozBQ5IkdcbgIUmSOmPwkCRJnTF4SJKkzhg8JElSZwwekiSpMwYPSZLUmaEHjySvSHJRkl8m\nWZ/kE0n+pK/MaUk29z3OHlabJUnS1Aw9eAAPA04FDgMeDewGfC7JbfrKnQPsDxzQPEa6bKQkSdpx\nuw67AaWUo3qfJzkOuB5YAny1Z9VNpZQbOmyaJElq2UwY8ei3D1CAG/uWP7I5FPPDJO9KcochtE2S\nJO2AoY949EoS4BTgq6WUy3pWnQN8DFgL3At4A3B2ksNLKaX7lkqSpKmYUcEDeBdwH+AhvQtLKWf2\nPL00yfeBNcAjgfO3VdmyZctYsGDBFstGRkYYGXF6iCRJK1asYMWKFVss27Bhw7Ruc8YEjyTvAI4C\nHlZKuXa8sqWUtUlGgQMZJ3gsX76cxYsXt9tQSZLmiEFfxleuXMmSJUumbZszIng0oeNJwCNKKesm\nUP4uwB2BcQOKJEmaWYY+uTTJu4CnA08DfpNk/+Yxv1m/V5I3Jzksyd2SHAF8ErgcOHd4LZckSZM1\n9OABPAvYG/gScE3P45hm/e+A+wGfAlYD7wW+BTy8lHJL142VJElTN/RDLaWUccNPKWUT8LiOmiNJ\nkqbRTBjxkCRJOwmDhyRJ6ozBQ5IkdcbgIUmSOmPwkCRJnTF4SJKkzhg8JElSZwwekiSpMwYPSZLU\nGYOHJEnqjMFDkiR1xuAhSZI6Y/CQJEmdMXhIkqTOGDwkSVJnDB6SJKkzBg9JktQZg4ckSeqMwUOS\nJHXG4CFJkjpj8JAkSZ0xeEiSpM4YPCRJUmcMHpIkqTMGD0mS1BmDhyRJ6ozBQ5IkdcbgIUmSOmPw\nkCRJnTF4SJKkzhg8JElSZwwekiSpMwYPSZLUGYOHJEnqjMFDkiR1xuAhSZI6Y/CQJEmdMXhIkqTO\nGDwkSVJnDB6SJKkzQw8eSV6R5KIkv0yyPsknkvzJgHKvSXJNko1Jzkty4DDaK0mSpm7owQN4GHAq\ncBjwaGA34HNJbjNWIMnLgOcBxwOHAr8Bzk2ye/fNlSRJU7XrsBtQSjmq93mS44DrgSXAV5vFLwBO\nLqV8pilzLLAeeDJwZmeNlSRJO2QmjHj02wcowI0ASe4BHAB8YaxAKeWXwDeBw4fRQEmSNDUzKngk\nCXAK8NVSymXN4gOoQWR9X/H1zTpJkjRLDP1QS593AfcBHjLshkiSpPbNmOCR5B3AUcDDSinX9qy6\nDgiwP1uOeuwPXDxencuWLWPBggVbLBsZGWFkZKSVNkuSNJutWLGCFStWbLFsw4YN07rNGRE8mtDx\nJOARpZR1vetKKWuTXAccAXyvKb839SyYd45X7/Lly1m8ePH0NFqSpFlu0JfxlStXsmTJkmnb5tCD\nR5J3ASPAE4HfJNm/WbWhlLKp+fkU4JVJfgxcCZwMXAV8quPmSpKkHTD04AE8izp59Et9y58BnA5Q\nSnlzkj2B91DPevkK8PhSys0dtlOSJO2goQePUsqEzqwppZwEnDStjZEkSdNqRp1OK0mS5jaDhyRJ\n6ozBQ5IkdcbgIUmSOmPwkCRJnTF4SJKkzhg8JElSZwwekiSpMwYPSZLUGYOHJEnqjMFDkiR1xuAh\nSZI6Y/CQJEmdMXhIkqTOGDwkSVJnDB6SJKkzBg9JktQZg4ckSeqMwUOSJHXG4CFJkjpj8JAkSZ0x\neEiSpM4YPCRJUmcMHpIkqTMGD0mS1BmDhyRJ6ozBQ5IkdcbgIUmSOmPwkCRJnZlS8EhyRZI7Dli+\nT5IrdrxZkiRpLprqiMfdgV0GLN8D+OMpt0aSJM1pu06mcJIn9jw9MsmGnue7AEcAV7bQLkmSNAdN\nKngAn2z+LcAH+9bdQg0dL97BNkmSpDlqUsGjlDIPIMla4IGllNFpaZUkSZqTJjviAUAp5R5tN0SS\nJM19UwoeAEmOoM7p2I++SaqllGfuYLskSdIcNKXgkeRE4ATg28C11DkfkiRJ45rqiMezgONKKR9q\nszGSJGlum+p1PHYHLmyzIZIkae6bavD4T+BpbTZEkiTNfVM91DIfOD7Jo4HvUa/h8XullBftaMMk\nSdLcM9URj/sBlwCbgfsCD+h5/PlkK0vysCRnJbk6yea+K6SS5LRmee/j7Cm2XZIkDclUr+PxFy23\nYy9qkHkf8PFtlDkHOA5I8/ymltsgSZKm2ZSv49GmUspngc8CJMk2it1USrmhu1ZJkqS2TfU6Hucz\nzrU7SimPmnKLtu2RSdYDPwe+CLyylHLjNGxHkiRNk6mOeFzS93w36tyO+7L1zePacA7wMWAtcC/g\nDcDZSQ4vpXjxMkmSZompzvFYNmh5kpOA2+5Ig7axvTN7nl6a5PvAGuCRwPltb0+S5pJ169YxOtrO\nPT1XrVrVSj3aebU9x+MM4CLgJS3Xu4VSytoko8CBjBM8li1bxoIFC7ZYNjIywsjIyHQ2T5JmjHXr\n1nHwwYvYtGnjsJuiGWjFihWsWLFii2UbNmyY1m22HTwOBza1XOdWktwFuCP1PjHbtHz5chYvXjzd\nzZGkGWt0dLQJHWcAi1qo8WzgVS3Uo5lg0JfxlStXsmTJkmnb5lQnl/af8hrgj4BDgJOnUN9e1NGL\nsTNa7pnk/sCNzeNE6hyP65pybwIuB86dSvslaeezCGjji5iHWrRjpjri0T8OsxlYDZxQSvncFOo7\nhHrIpDSPtzTLPwg8h3rBsmOBfYBrqIHjhFLKLVtXJUmSZqqpTi59RpuNKKVcwPhXUX1cm9uTJEnD\nsUNzPJIs4Q8HDS8tpVy8402SJElz1VTneOwHfIR6OusvmsX7NBcWe6pXGJUkSYNM9SZxpwK3A/60\nlHKHUsodqBcP2xt4e1uNkyRJc8tUD7U8Dnh0KeX305tLKZcleS4wlcmlkiRpJzDVEY95wKAzSm7Z\ngTolSdIcN9WQ8EXgbUnuPLYgyR8Dy4EvtNEwSZI090w1eDyPOp/jyiRrkqyh3sBtb+D5bTVOkiTN\nLVO9jsdPkywGHg3cu1m8qpTy+dZaJkmS5pxJjXgkeVSSy5LsXarzSimnllJOBb6V5NIkR05TWyVJ\n0iw32UMtLwTeW0r5Zf+KUsoG4D14qEWSJG3DZIPH/YHPjrP+c9T7qkiSJG1lssFjfwafRjvmVuBO\nU2+OJEmayyYbPK6mXqF0W+4HXDv15kiSpLlsssHjbODkJPP7VyS5DfBq4DNtNEySJM09kz2d9rXA\nXwGXJ3kHsLpZfm/gucAuwOvaa54kSZpLJhU8SinrkzwYeDfwBiBjq4BzgeeWUta320RJkjRXTPoC\nYqWUnwBHJbk9cCA1fPyolPLzthsnSZLmlqnenZYmaHyrxbZIkqQ5zjvJSpKkzhg8JElSZwwekiSp\nMwYPSZLUGYOHJEnqjMFDkiR1xuAhSZI6Y/CQJEmdMXhIkqTOGDwkSVJnDB6SJKkzBg9JktQZg4ck\nSeqMwUOSJHXG4CFJkjpj8JAkSZ0xeEiSpM4YPCRJUmcMHpIkqTMGD0mS1BmDhyRJ6ozBQ5Ikdcbg\nIUmSOjMjgkeShyU5K8nVSTYneeKAMq9Jck2SjUnOS3LgMNoqSZKmbkYED2Av4BLgOUDpX5nkZcDz\ngOOBQ4HfAOcm2b3LRkqSpB2z67AbAFBK+SzwWYAkGVDkBcDJpZTPNGWOBdYDTwbO7KqdkiRpx8yU\nEY9tSnIP4ADgC2PLSim/BL4JHD6sdkmSpMmb8cGDGjoKdYSj1/pmnSRJmiVmxKGW6bJs2TIWLFiw\nxbKRkRFGRkaG1CJJkmaOFStWsGLFii2WbdiwYVq3ORuCx3VAgP3ZctRjf+Di8V64fPlyFi9ePI1N\nkyRp9hr0ZXzlypUsWbJk2rY54w+1lFLWUsPHEWPLkuwNHAZcOKx2SZKkyZsRIx5J9gIOpI5sANwz\nyf2BG0spPwVOAV6Z5MfAlcDJwFXAp4bQXEmSNEUzIngAhwDnUyeRFuAtzfIPAs8spbw5yZ7Ae4B9\ngK8Ajy+l3DyMxkqSpKmZEcGjlHIB2znsU0o5CTipi/ZIkqTpMePneEiSpLnD4CFJkjpj8JAkSZ0x\neEiSpM4YPCRJUmcMHpIkqTMGD0mS1BmDhyRJ6ozBQ5IkdcbgIUmSOmPwkCRJnTF4SJKkzhg8JElS\nZwwekiSpMwYPSZLUGYOHJEnqjMFDkiR1xuAhSZI6Y/CQJEmdMXhIkqTOGDwkSVJnDB6SJKkzBg9J\nktQZg4ckSerMrsNugCR1ad26dYyOjrZW37777svChQtbqw/abeOqVataqWe6tdnO6fidqD0GD0k7\njXXr1nHwwYvYtGlja3XOn78nq1evau2DbjraOLNdC8xj6dKlrdXY9u9E7TJ4SNppjI6ONh/oZwCL\nWqhxFZs2LWV0dLS1D7n223g28KoW6pkuvwA2M5N/J2qXwUPSTmgRsHjYjdiOtto4Ow61zI7fidrg\n5FJJktQZg4ckSeqMwUOSJHXG4CFJkjpj8JAkSZ0xeEiSpM4YPCRJUme8jock7aA2L/c9Wy5xLk2V\nwUOSpqz9y31Lc53BQ5KmrO3LfcPMv8S5tGMMHpK0w9q83LeHWjS3OblUkiR1ZlYEjyQnJtnc97hs\n2O2SJEmTM5sOtfwAOAJI8/zWIbZFkiRNwWwKHreWUm4YdiMkSdLUzYpDLY2DklydZE2SM5LcddgN\nkiRJkzNbgsc3gOOAI4FnAfcAvpxkr2E2SpIkTc6sONRSSjm35+kPklwE/AQ4BjhtOK2SJM1UbV4B\ndt9992XhwoWt1bezmxXBo18pZUOSy4EDxyu3bNkyFixYsMWykZERRkZGprN5kqShaf9qsvPn78nq\n1avmZPhYsWIFK1as2GLZhg0bpnWbszJ4JLktNXScPl655cuXs3hxWxf1kSTNfG1fTXYVmzYtZXR0\ndE4Gj0FfxleuXMmSJUumbZuzIngk+Tfg09TDK38MvBq4BVgx3uskSTurNq8mqzbNiuAB3AX4MHBH\n4Abgq8CDSik/G2qrJEnSpMyK4FFKcVKGJElzwGw5nVaSJM0BBg9JktQZg4ckSeqMwUOSJHXG4CFJ\nkjpj8JAkSZ0xeEiSpM4YPCRJUmcMHpIkqTMGD0mS1BmDhyRJ6ozBQ5IkdcbgIUmSOmPwkCRJnTF4\nSJKkzuw67AaoPevWrWN0dLTVOvfdd18WLlzYap2StLNr++/1bPpbbfCYI9atW8fBBy9i06aNrdY7\nf/6erF69atbs0JI0003H3+vZ9Lfa4DFHjI6ONjvxGcCilmpdxaZNSxkdHZ0VO7MkzQbt/72eXX+r\nDR5zziJg8bAbIUnarp3z77WTSyVJUmcMHpIkqTMGD0mS1BmDhyRJ6ozBQ5IkdcbgIUmSOuPptENy\n4YUXsnTpM7j11t+1Ut/NN9/USj07u535aoIzVZu/k1WrVrVSj3Y+be47O/t+aPAYks985jP85Cfr\n2bz52S3VeCFwVUt17Zx29qsJzkTTdUVeaeKuBeaxdOnSYTdkzjB4DNEuu9yRzZvf0FJtbwC+3FJd\nO6ed/WqCM1H7v5OzgVe1UI92Hr8ANtPuVaF37v3Q4CFtZee8muDM1tbvZOce4taOaPPvws69Hzq5\nVJIkdcbgIUmSOmPwkCRJnTF4SJKkzhg8JElSZwwekiSpM55Oq+1q8yp7N910E3vssceMrG+6riY4\nk/sPvLqqpG4ZPDSO6bhi3y5AO5eJn5762jQb+s+rq0rqlsFD42j7in1jV+ub6fW1Zab3H3h1VUld\nM3hoAtq+auRMr69tM/X9SlL3nFwqSZI6Y/CQJEmdmVXBI8lzk6xN8tsk30jywGG3Sb1WDLsBOyH7\nvHv2effs87lk1gSPJE8B3gKcCDwA+C5wbpJ9h9ow9fCPQ/fs8+7Z592zz+eSWRM8gGXAe0opp5dS\nfgg8C9gIPHO4zZIkSRM1K4JHkt2AJcAXxpaVUgrweeDwYbVLkiRNzmw5nXZf6pWT1vctXw8c3H1z\n2lHKTcDKlmq7uqV6JEmaPrMleEzWfJi+S2C3Yd68edx669XUgZw2nU1716P42iTrvAr4rxbr2x7r\n236fb8/aWuPZZ7f2/2XevHls3ry5lbrWrl3b/DSTfie9fd7273g66pwL9U1mP5/p73c66qz/T9r6\nP9xTz/xWKuyTesRiZmsOtWwE/rqUclbP8g8AC0opR/eVfxo79tdYkqSd3dNLKR9uu9JZMeJRSrkl\nyXeAI4CzAJKkef72AS85F3g6cCWwqaNmSpI0F8wH7k79LG3drBjxAEhyDPAB6tksF1HPcvkb4N6l\nlBuG2DRJkjRBs2LEA6CUcmZzzY7XAPsDlwBHGjokSZo9Zs2IhyRJmv1mxXU8JEnS3GDwkCRJnZk1\nwSPJiUk29z0u61l/2oD1Z/fVsUeSdyYZTfKrJP+TZL/u383skeTOST7U9NnGJN9NsrivzGuSXNOs\nPy/JgX3r7fdJ2F6fu6+3q7nxZH9/bk5yak8Z9/EWba/Pk3zAfbxdSeYlOTnJFc1+/OMkrxxQbtr3\n9VkTPBo/oE4sPaB5PLRv/Tl960f61p8CPAH4a+DhwJ2Bj01je2e1JPtQr3RzE3AksAh4MfDznjIv\nA54HHA+/27tSAAAK7UlEQVQcCvyGevO+3Xuqst8naCJ93nBfb88h/KEfDwAeAxTgTHAfnybj9nnz\ns/t4u14O/BPwHODewL8A/5LkeWMFOtvXSymz4kG9K+3KcdafBnx8nPV7U/+YH92z7GBgM3DosN/f\nTHwAbwQu2E6Za4Blff38W+AY+33a+tx9fXp/B6cAl/c8dx/vvs/dx9vv408D7+1b9j/A6T3PO9nX\nZ9uIx0FJrk6yJskZSe7at/6RSdYn+WGSdyW5Q8+6JdTTh3tvNLcaWIc3mtuWvwS+neTMpl9XJvnH\nsZVJ7kH9JtLbp78Evskf+vQQ7PfJGLfPe7ivT4PUqyQ/HXhf89x9fJr193kP9/F2XQgckeQggCT3\nBx5CvW57p/v6bAoe3wCOow4/Pwu4B/CVJHs1688BjgUeRR1CegRwdpI06w8Abm46stf6Zp22dk/g\n2cBq4LHAu4G3J/m7Zv0B1CHRQTfvG+vT/bHfJ2N7fQ7u69PpaGAB8MHmufv49Ovvc3Afnw5vBP4b\n+GGSm4HvAKeUUj7SrO9sX59NFxDrvXTrD5JcBPwEOAY4rZRyZs/6S5N8H1gDPBI4v7OGzi3zgItK\nKa9qnn83yX2pwe9Dw2vWnLbdPndfn1bPBM4ppVw37IbsRLbqc/fxafEU4GnAU4HLgD8H3pbkmlJK\np3/PZ9OIxxZKKRuAy4EDt7F+LTDas/46YPcke/cV3b9Zp61dy9a3TlwFLGx+vg4ItQ979fap/T45\n2+vzrbivtyPJQuDRwHt7FruPT6Nt9PlW3Mdb8WbgjaWUj5ZSLi2l/BewHHhFs76zfX3WBo8kt6Xu\nhNduY/1dgDv2rP8OcCv1xnJjZQ6m/kH/+rQ2dvb6GnXiUK+DqSNNY38MrmPLPt0bOIx6PBHs98ka\nt88HcV9vzTOpQ8a/P23TfXzabdXng7iPt2JP4Hd9yzbT5IBO9/Vhz7SdxIzcf6OeunM34MHAedQd\n9o7AXtQ0d1iz/gjg29Rvirv11PEuYC11uG4J9Y/8V4b93mbqgzqR6CZqIr4XdZjuV8BTe8r8C/Az\n6qTIPwM+CfwI2N1+b7/P3denrd9DvZv16wascx/vsM/dx6etv0+jTgI9qunXo4Hrgdf3lOlkXx96\nZ0yi01YAV1FP7VkHfBi4R7NuPvBZalrbBFxBnZR3p7469gBOpQ7Z/Qr4KLDfsN/bTH40O+n3gI3A\npcAzB5Q5iXoa1kbqbZQPtN+np8/d16etzx9D/TZ44DbWu4931Ofu49PW33sBb21Cw2+aQPFqYNe+\nctO+r3uTOEmS1JlZO8dDkiTNPgYPSZLUGYOHJEnqjMFDkiR1xuAhSZI6Y/CQJEmdMXhIkqTOGDwk\nSVJnDB6SOpXkbkk2J7nfsNsCkOS0JB+f4msvSPLUnuebkzxxB9uzKMlPk9xmR+qRZiqDh9SyJPsm\neXeSnyTZlOTaJOckOXzYbZtBOr9kctuBpwkY+5VSPtJGfWNKKauoN9x6cZv1SjOFwUNq38eB+wN/\nBxxEveHSl6g3NFSVIW2zzcDzfOqNt6bDB4BnJ/FvtOYcd2qpRUkWAA8FXlZK+XIp5aellG+XUt5U\nSvlMb7kk/5nk+iQbkny+/5t4kpcnua5Z/59J3pDk4p715yd5a99rPpHk/T3Pd0/y70muSvLrJF9P\n8oie9X+f5OdJHpvksiS/akZn9u+r95lJftCM4Fyd5O2TeS8T6Lf7Jjm72f51SU5Pcsee9ecneVuS\nNyX5WTOKdGJfHQcn+WqS3yb5fpJH9h36uKL595Jm+Rf7Xv/iJNckGU3yjiS7jNPefYFHAZ8esPrO\nzXvZmGRNkr/ued3YqMtTknytp60P76vjPOAOwCOQ5hiDh9SuXzePJyfZfZxy/0MdATkSWAysBD6f\nZB+AJMcAJwIvBw4BrgWew+S/sb+TenvxY6i3uf4ocE6Se/WU2ZM6rP904GHAQuDfx1YmeTbwDuA/\ngD8FngBcPtH3sj1NWPsC8J3m9UcC+wFn9hU9ltq3h1Jv331CkiOaOuYBn6LeLfOBwD8Bb2TL/jqU\nOurxKOAA4K961j0KuCf1Vt/HAsc1j215KPCb5rBIv9dQ+/l+wH8BH0lycF+ZNwP/Bvw59bDKWUlu\nP7aylHILcAn19yHNLcO+Va8PH3PtARxNvWX0RuCrwOuAP+tZ/xDg58Bufa/7EfCPzc9fA97et/7r\nwMqe5+cDb+0r8wng/c3PC4FbgAP6ypwHvLb5+e+ptya/e8/6ZwPX9Dy/Cnj1Nt7rdt/LgNfcDdgM\n3K95/q/AOX1l7tKUObDnvV7QV+abwOubnx8H3ETPrdOBI5o6njhouz3lTqOOhqRn2X8DHx7nd/wC\n4EcDlm8G3jHg9/aOvja8pGf9LsC63mXN8o8B7xv2/uzDR9sPRzyklpVSPgHcmTq34xzqcPnKJMc2\nRe4P3A64sTm08KskvwLuTv3WDbAIuKiv6q9Psin3pX6oXd63nYcDvSMeG0spV/Y8v5Y64kCSOzXv\nZYvDEj3Gey/32sZrBtXxqL7Xr6KOVvTW8b2+1/2+ncCfAD8tpdzQs76//8ZzaSmld3Skt+5BbgNs\n2sa6b/Q9/zr19zmwTCnld8C3B5T5LXU0SppTdh12A6S5qJRyM/XwwReA1yV5L/Bq4HTgtsA11EDS\nP8nyF5PYzOYBr9+t5+fbArdSD19s7iv3656fb+lvfk+9v91OG9p4L7cFzqIePumv49rttLOtL0+T\nrXsUuP0469twB+DH07wNqXOOeEjdWAXs1fy8kjrH4HellCv6Hjf2lD+sr44H9T2/AfijsSfNPIf7\n9qy/mDrisf+A7Vw/kUaXUn4NXEk9bDHIRN7L9qykzh35yYA6thd8xqwG7tqM0Iw5tK/Mzc2/25w0\nOgkXAwc081P69f+eHkT9fQ4s00xiXTKgzH2b7UhzisFDalGSOyT5QpKnJ/mzJHdP8rfAS4FPApRS\nPk8dfv9kksc0Zzo8OMlrkyxuqnob8MwkxyU5KMmrqR/Ovb4IPCHJUc3kxXcDv5/QWUr5EfBh4PQk\nRzdtObQ5W+bxk3hbJwEvTvL8JAcmWZzkeZN4L9vzTuq3+48kOSTJPZMcmeT9SSZ62u151Hkapzf9\n/hDgtdSRi7FDKNdTR3Ael2S/JHtPsO5BLqaOejxkwLq/TfKMnt/bA4FT+8o8N8mTm9/bu6i/t96z\nke5GPcT1+R1oozQjGTykdv2aevz+hcAFwPeph1jeQ73uw5ijgC9TP2xWUwPCQmA9QCnlTOBk4E3U\n4/93pQaLXu8HPtg8vgSsYeu5GMdRD+/8O/BD6jVGDqFOZpyQUsrpzft5NvAD6mGRAyf6XrZVbU/9\n11I/wOcB51LncrwV+HnPvItxz+YppWwGnkQdVboI+L/U4BGauRjNXIrnU894uZomCE5Fs70PAEsH\nvK8TgacC323WP7WUsrqv3MubxyXAg4G/7BshehrwuVLKT6faRmmmypbzqSTNVM11K55USpnoSMJO\nrRn1+DL1zJi101D//tQgtniiAaEZybgCeEAppX+y7FiZ3ahnBT21lNI/UVWa9ZxcKmlOSPJk6ojT\nj6hXjD0F+Op0hA6AUsr6JP9AHd2ZzMjE9g4fLQReZ+jQXGXwkDRX3I56aOqu1PkX5wEvmc4NllLO\nmsrLtlPnGuphM2lO8lCLJEnqjJNLJUlSZwwekiSpMwYPSZLUGYOHJEnqjMFDkiR1xuAhSZI6Y/CQ\nJEmdMXhIkqTOGDwkSVJn/h9NfqwDb7R1vgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10f05b210>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(lengths, bins=20)\n",
    "plt.xlabel('Sequence length (bp)')\n",
    "plt.ylabel('Count')\n",
    "plt.title(str(len(gc_contents)) + ' orchid sequences')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}