intro-programming-python-instructor.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 in the Jupyter Notebook Environment"
   ]
  },
  {
   "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\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The gray boxes are cells. We write code in the cells with instructions for the computer to execute. Let's start by adding 5 and 3 and printing the result. "
   ]
  },
  {
   "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": [
    "Here we did 2 different things. We added 5 and 3 using the `+` **operator** within the `print()` **function**. Functions like `print()` have parentheses that take an argument to perform a task. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try giving the print function a phrase to print instead of an equation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (3449611317.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Input \u001b[0;32mIn [2]\u001b[0;36m\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 returned an error, but there's a lot to learn here:\n",
    "\n",
    "- Errors can be really helpful.\n",
    "- It's common to make mistakes, don't be discouraged\n",
    "- Numbers do not need quotes, 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 is called a `string`. A string is a sequence of characters denoted using quotes. You can use either single `''` or double quotes `\"\"` in Python.  We can check the data type of a value using the `type()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('Hello, World')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"Hello World\")"
   ]
  },
  {
   "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": 6,
   "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 items by inserting commas. So we can combine our greeting and neighbor to greet our neighbor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aloha John\n"
     ]
    }
   ],
   "source": [
    "neighbor = 'John'\n",
    "print(greeting, neighbor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, we can work with numbers too. Whole numbers are refered to as an `integer` data type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My daughter is 5 years old.\n",
      "Next year she will be 6\n"
     ]
    }
   ],
   "source": [
    "age = 5\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.\n",
    "\n",
    "For numeric data, there's also `float` - for decimal numbers/fractions.\n",
    "\n",
    "And you create floats just by using a decimal point in your number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": [
    "When we combine different data types, Python implicitly determines how to combine the data (or if it is possible). For example, let's look at the result of adding a float and an integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_float <class 'float'>\n",
      "my_integer <class 'int'>\n",
      "60.5 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "my_float = 50.5\n",
    "print(\"my_float\", type(my_float))\n",
    "my_integer = 10\n",
    "print(\"my_integer\", type(my_integer))\n",
    "float_plus_integer = my_float + my_integer\n",
    "print(float_plus_integer, type(float_plus_integer))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider an example we may not expect to work, a float and a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'float' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [11]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m my_float \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m50.0\u001b[39m\n\u001b[1;32m      2\u001b[0m my_string \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHello\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mmy_float\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mmy_string\u001b[49m)\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'float' and 'str'"
     ]
    }
   ],
   "source": [
    "my_float = 50.0\n",
    "my_string = \"Hello\"\n",
    "print(my_float + my_string)"
   ]
  },
  {
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n"
     ]
    }
   ],
   "source": [
    "name = 'Python'\n",
    "print(name[0])"
   ]
  },
  {
   "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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y\n",
      "t\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "print(name[1])\n",
    "print(name[2])\n",
    "print(name[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use negative numbers to count backwards from the end of the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "print(name[-1])\n",
    "print(name[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extract subsequences of strings using a concept called **slices**. We can do that with the format **[start:end]** where **start is inclusive** and **end is exclusive**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "hon\n",
      "Pyt\n"
     ]
    }
   ],
   "source": [
    "print(name[0:6])\n",
    "print(name[3:6])\n",
    "print(name[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the word 'Python' only has 6 letters and `name[0:6]` includes the whole thing even though `name[5]` returns the last letter. Because the end parameter in a slice is exclusive, it is the number just after."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For slice notation, you need to include the colon but the start and stop parameters are optional. By default they will be the beginning and end of the sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "hon\n",
      "Pyt\n"
     ]
    }
   ],
   "source": [
    "print(name[:])\n",
    "print(name[3:])\n",
    "print(name[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One more optional parameter you can use is called a **step** in the format **[start:end:step]**. This parameter determines what you \"count by\" and is 1 by default. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "Pto\n"
     ]
    }
   ],
   "source": [
    "print(name[0:6:1])\n",
    "print(name[0:6:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also check if a letter exists in a string:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**True** and **False** are actually a new data type 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.\n",
    "\n",
    "Notice that the word `in` is bold and green in Jupyter notebooks. Commands like these are known as **keywords**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also check if a letter does **not** exist, by using the keyword `not`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' not in name"
   ]
  },
  {
   "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": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "print(3 + 3)\n",
    "my_variable_name = 3 + 3\n",
    "print(my_variable_name)"
   ]
  },
  {
   "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": 21,
   "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 one can put multiple sticky notes on the same object, one can have multiple variables referencing the same piece of data, and later move them around:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = y = 'pencil'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": 24,
   "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": 25,
   "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": [
    "### 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 `seq`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = 'ACCTGCATGC'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use indexes to retrieve the first couple nucleotides in the sequence and store them in variables. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = seq[0]\n",
    "b2 = seq[1]\n",
    "b3 = seq[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how these variables have numbers are part of the name. In Python your variable names can use numbers, but they cannot start with one. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (3233142308.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Input \u001b[0;32mIn [28]\u001b[0;36m\u001b[0m\n\u001b[0;31m    1a\u001b[0m\n\u001b[0m     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "1a"
   ]
  },
  {
   "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": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACC\n"
     ]
    }
   ],
   "source": [
    "first3 = b1 + b2 + b3\n",
    "print(first3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CCA\n"
     ]
    }
   ],
   "source": [
    "r3 = b3 + b2 + b1\n",
    "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": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [31]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m r3[\u001b[38;5;241m2\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mG\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "r3[2] = 'G'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CCA CCG\n"
     ]
    }
   ],
   "source": [
    "old_r3 = r3\n",
    "r3 = b3 + b2 + 'G'\n",
    "print(old_r3, 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": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCTGCATGC CGTA\n"
     ]
    }
   ],
   "source": [
    "rev = seq[9] + seq[8] + seq[7] + seq[6] # ...\n",
    "print(seq, rev)"
   ]
  },
  {
   "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": 34,
   "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 seq:\n",
    "    print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A few things happened here. \n",
    "\n",
    "1. First, we introduced a new keywords `for` and a previously introcuded keyword, `in`\\*. This constructs the loop and says we want to work on each element in `seq`. 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.\n",
    "\n",
    "\\* Note: the `in` keyword behavior is modifed by the `for` keyword. It does not check if the value on the left is a member of the collection of values on the right. Rather it is used as a seperator from the loop variable and the sequence. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before\n",
      "Loop: A\n",
      "Loop: C\n",
      "Loop: C\n",
      "Loop: T\n",
      "Loop: G\n",
      "Loop: C\n",
      "Loop: A\n",
      "Loop: T\n",
      "Loop: G\n",
      "Loop: C\n",
      "After\n"
     ]
    }
   ],
   "source": [
    "print('Before')\n",
    "for b in seq:\n",
    "    print('Loop:', b)\n",
    "print('After')"
   ]
  },
  {
   "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": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "for s in seq:\n",
    "    count = count + 1\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First exercise and summary in presentation: reverse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make this a hands-on exercise to write some code that reverses the sequence in `seq` and puts it in a variable called `rev`. Remember, you can add strings together and the order is important!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here!"
   ]
  },
  {
   "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 together: a **key** and a **value**.\n",
    "\n",
    "Dictionaries are createed using curly braces `{}`. Each key and value are seperated by a colon. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key': 'value', 'second_key': 2, 3: 'third_value'}\n"
     ]
    }
   ],
   "source": [
    "my_dictionary = {\"key\": \"value\", \"second_key\": 2, 3: \"third_value\"}\n",
    "print(my_dictionary)"
   ]
  },
  {
   "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": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 2, 'C': 4, 'G': 2, 'T': 2}\n"
     ]
    }
   ],
   "source": [
    "counts = {'A': 2, 'C': 4, 'G': 2, 'T': 2}\n",
    "print(counts)"
   ]
  },
  {
   "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": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have 2 As\n"
     ]
    }
   ],
   "source": [
    "print('I have', counts['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": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now I have 3 As\n"
     ]
    }
   ],
   "source": [
    "counts['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 `base`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have 4 Cs\n"
     ]
    }
   ],
   "source": [
    "base = 'C'\n",
    "print('I have', counts[base], base + '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 counts dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "C\n",
      "G\n",
      "T\n"
     ]
    }
   ],
   "source": [
    "for c in counts:\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we loop over the dictionary, the **loop variable** is set to each **key**. The loop doesn't directly give us the **value**, but we can get the value indirectly since we have the key and the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A 3\n",
      "C 4\n",
      "G 2\n",
      "T 2\n"
     ]
    }
   ],
   "source": [
    "for b in counts:\n",
    "    qty = counts[b]\n",
    "    print(b, 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 in the dictionary counts. This loop should look a lot like counting the bases in the sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here!"
   ]
  },
  {
   "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": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "comps = {'A':'T', 'T':'A'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So to read the complement of `A`, we can write `comps['A']`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T\n"
     ]
    }
   ],
   "source": [
    "print(comps['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": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "comps['C'] = 'G'\n",
    "comps['G'] = 'C'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}\n"
     ]
    }
   ],
   "source": [
    "print(comps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can complement the sequence from before by looking up the complement inside a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCTGCATGC CGTA GCAT\n"
     ]
    }
   ],
   "source": [
    "revcomp = ''\n",
    "# starting with rev, the already reversed sequence\n",
    "for s in rev:\n",
    "    c = comps[s]\n",
    "    revcomp = revcomp + c\n",
    "print(seq, rev, revcomp)\n"
   ]
  },
  {
   "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": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ACCTGCATGC', 'CGTA', 'GCAT'] <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "seqs = [seq, rev, revcomp]\n",
    "print(seqs, type(seqs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like with strings, we can use a for loop to iterate through each element in the list and perform commands. Let's use a for loop to print each element in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCTGCATGC\n",
      "CGTA\n",
      "GCAT\n"
     ]
    }
   ],
   "source": [
    "for s in seqs:\n",
    "    print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lists**, unlike strings, are **mutable**. So we can add or remove to a list, reorder it, or swap items out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "seqs[0] = 'AAAAAGGGGG'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['AAAAAGGGGG', 'CGTA', 'GCAT']\n"
     ]
    }
   ],
   "source": [
    "print(seqs)"
   ]
  },
  {
   "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": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['CGTA', 'GCAT']\n"
     ]
    }
   ],
   "source": [
    "del seqs[0]\n",
    "print(seqs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making choices / Conditionals\n",
    "\n",
    "When writing programs, it's usefull 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` keyword, 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": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequence contains GC\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "if 'GC' in seq:\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": [
    "Let's do an example where we combine the concepts of **for loops** and **if statements**. In this example, let's write code that calculates the GC-content percentage of a DNA sequence. So what is the percentage of 'G' and 'C' nucelotides in a DNA sequence. We can use the **for loop** to go through each nucleotide and the **if statement** to determine if the letter is a 'G' or a 'C'. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GC-content percentage: 60.0 %\n"
     ]
    }
   ],
   "source": [
    "gc = 0\n",
    "atgc = 0\n",
    "for s in seq:\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": [
    "Notice the new operator `==`. It is a logical operator that means \"is equal to\". Its counterpart, `!=`, means \"is not equal to\"."
   ]
  },
  {
   "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 keyword `or` in between the two tests. So we can make this code a little shorter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GC-content percentage: 60.0 %\n"
     ]
    }
   ],
   "source": [
    "gc = 0\n",
    "atgc = 0\n",
    "for s in seq:\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": [
    "### Recap in presentation: loops, dictionaries, lists, and conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that there is a counterpart for `or` called `and` which looks for both conditional expressions resulting in **True** instead of at least 1. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, another thing we can test for is if values are greater or less than others. This can be done with the operators: `<`, `>`, `<=`, `>=`, which perform in the same way as the mathematical expressions. 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 55 is high. We start by writing the first condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Low\n"
     ]
    }
   ],
   "source": [
    "percent = 20\n",
    "if percent < 35:\n",
    "    print('Low')\n",
    "else:\n",
    "    if percent < 56:\n",
    "        print('Normal')\n",
    "    else:\n",
    "        print('High')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how adding multiple options results in lots of indentation. There is another keyword, `elif`, that we can use to shorten this. `elif` combines `else` and `if`. Here is the previous code but with `elif`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Low\n"
     ]
    }
   ],
   "source": [
    "percent = 20\n",
    "if percent < 35:\n",
    "    print('Low')\n",
    "elif percent < 56:\n",
    "    print('Normal')\n",
    "else:\n",
    "    print('High')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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.\n",
    "\n",
    "Let's use the **len** function to get the length of our sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(len(seq)) # 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": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 2\n"
     ]
    }
   ],
   "source": [
    "print(len(comps), len(seqs))"
   ]
  },
  {
   "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": 63,
   "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": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sorted in module builtins:\n",
      "\n",
      "sorted(iterable, /, *, key=None, reverse=False)\n",
      "    Return a new list containing all items from the iterable in ascending order.\n",
      "    \n",
      "    A custom key function can be supplied to customize the sort order, and the\n",
      "    reverse flag can be set to request the result in descending order.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sorted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's also plenty of documentation on the internet: https://docs.python.org/3/library/functions.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many data types have their own functions **built into the data type**. We talked about strings, and they often contain multiple words separated by spaces. So there's a built-in function called **split()** that makes a list of those words. **By default, it seperates by removing whitespace** but it can optionally take an input string to remove instead. These functions use a different syntax, `datatype.function_name()` instead of `function_name()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "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. Functions like these that are part of something are called **methods**. There are thousands of functions that are **part of** different data types. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the `help()` function on the str data type and see what methods it has. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class str in module builtins:\n",
      "\n",
      "class str(object)\n",
      " |  str(object='') -> str\n",
      " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      " |  \n",
      " |  Create a new string object from the given object. If encoding or\n",
      " |  errors is specified, then the object must expose a data buffer\n",
      " |  that will be decoded using the given encoding and error handler.\n",
      " |  Otherwise, returns the result of object.__str__() (if defined)\n",
      " |  or repr(object).\n",
      " |  encoding defaults to sys.getdefaultencoding().\n",
      " |  errors defaults to 'strict'.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __format__(self, format_spec, /)\n",
      " |      Return a formatted version of the string as described by format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the string in memory, in bytes.\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  capitalize(self, /)\n",
      " |      Return a capitalized version of the string.\n",
      " |      \n",
      " |      More specifically, make the first character have upper case and the rest lower\n",
      " |      case.\n",
      " |  \n",
      " |  casefold(self, /)\n",
      " |      Return a version of the string suitable for caseless comparisons.\n",
      " |  \n",
      " |  center(self, width, fillchar=' ', /)\n",
      " |      Return a centered string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  count(...)\n",
      " |      S.count(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the number of non-overlapping occurrences of substring sub in\n",
      " |      string S[start:end].  Optional arguments start and end are\n",
      " |      interpreted as in slice notation.\n",
      " |  \n",
      " |  encode(self, /, encoding='utf-8', errors='strict')\n",
      " |      Encode the string using the codec registered for encoding.\n",
      " |      \n",
      " |      encoding\n",
      " |        The encoding in which to encode the string.\n",
      " |      errors\n",
      " |        The error handling scheme to use for encoding errors.\n",
      " |        The default is 'strict' meaning that encoding errors raise a\n",
      " |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and\n",
      " |        'xmlcharrefreplace' as well as any other name registered with\n",
      " |        codecs.register_error that can handle UnicodeEncodeErrors.\n",
      " |  \n",
      " |  endswith(...)\n",
      " |      S.endswith(suffix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S ends with the specified suffix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      suffix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  expandtabs(self, /, tabsize=8)\n",
      " |      Return a copy where all tab characters are expanded using spaces.\n",
      " |      \n",
      " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
      " |  \n",
      " |  find(...)\n",
      " |      S.find(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  format(...)\n",
      " |      S.format(*args, **kwargs) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  format_map(...)\n",
      " |      S.format_map(mapping) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from mapping.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  index(...)\n",
      " |      S.index(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  isalnum(self, /)\n",
      " |      Return True if the string is an alpha-numeric string, False otherwise.\n",
      " |      \n",
      " |      A string is alpha-numeric if all characters in the string are alpha-numeric and\n",
      " |      there is at least one character in the string.\n",
      " |  \n",
      " |  isalpha(self, /)\n",
      " |      Return True if the string is an alphabetic string, False otherwise.\n",
      " |      \n",
      " |      A string is alphabetic if all characters in the string are alphabetic and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  isascii(self, /)\n",
      " |      Return True if all characters in the string are ASCII, False otherwise.\n",
      " |      \n",
      " |      ASCII characters have code points in the range U+0000-U+007F.\n",
      " |      Empty string is ASCII too.\n",
      " |  \n",
      " |  isdecimal(self, /)\n",
      " |      Return True if the string is a decimal string, False otherwise.\n",
      " |      \n",
      " |      A string is a decimal string if all characters in the string are decimal and\n",
      " |      there is at least one character in the string.\n",
      " |  \n",
      " |  isdigit(self, /)\n",
      " |      Return True if the string is a digit string, False otherwise.\n",
      " |      \n",
      " |      A string is a digit string if all characters in the string are digits and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  isidentifier(self, /)\n",
      " |      Return True if the string is a valid Python identifier, False otherwise.\n",
      " |      \n",
      " |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,\n",
      " |      such as \"def\" or \"class\".\n",
      " |  \n",
      " |  islower(self, /)\n",
      " |      Return True if the string is a lowercase string, False otherwise.\n",
      " |      \n",
      " |      A string is lowercase if all cased characters in the string are lowercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |  \n",
      " |  isnumeric(self, /)\n",
      " |      Return True if the string is a numeric string, False otherwise.\n",
      " |      \n",
      " |      A string is numeric if all characters in the string are numeric and there is at\n",
      " |      least one character in the string.\n",
      " |  \n",
      " |  isprintable(self, /)\n",
      " |      Return True if the string is printable, False otherwise.\n",
      " |      \n",
      " |      A string is printable if all of its characters are considered printable in\n",
      " |      repr() or if it is empty.\n",
      " |  \n",
      " |  isspace(self, /)\n",
      " |      Return True if the string is a whitespace string, False otherwise.\n",
      " |      \n",
      " |      A string is whitespace if all characters in the string are whitespace and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  istitle(self, /)\n",
      " |      Return True if the string is a title-cased string, False otherwise.\n",
      " |      \n",
      " |      In a title-cased string, upper- and title-case characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |  \n",
      " |  isupper(self, /)\n",
      " |      Return True if the string is an uppercase string, False otherwise.\n",
      " |      \n",
      " |      A string is uppercase if all cased characters in the string are uppercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |  \n",
      " |  join(self, iterable, /)\n",
      " |      Concatenate any number of strings.\n",
      " |      \n",
      " |      The string whose method is called is inserted in between each given string.\n",
      " |      The result is returned as a new string.\n",
      " |      \n",
      " |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n",
      " |  \n",
      " |  ljust(self, width, fillchar=' ', /)\n",
      " |      Return a left-justified string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  lower(self, /)\n",
      " |      Return a copy of the string converted to lowercase.\n",
      " |  \n",
      " |  lstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  partition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |      \n",
      " |      This will search for the separator in the string.  If the separator is found,\n",
      " |      returns a 3-tuple containing the part before the separator, the separator\n",
      " |      itself, and the part after it.\n",
      " |      \n",
      " |      If the separator is not found, returns a 3-tuple containing the original string\n",
      " |      and two empty strings.\n",
      " |  \n",
      " |  removeprefix(self, prefix, /)\n",
      " |      Return a str with the given prefix string removed if present.\n",
      " |      \n",
      " |      If the string starts with the prefix string, return string[len(prefix):].\n",
      " |      Otherwise, return a copy of the original string.\n",
      " |  \n",
      " |  removesuffix(self, suffix, /)\n",
      " |      Return a str with the given suffix string removed if present.\n",
      " |      \n",
      " |      If the string ends with the suffix string and that suffix is not empty,\n",
      " |      return string[:-len(suffix)]. Otherwise, return a copy of the original\n",
      " |      string.\n",
      " |  \n",
      " |  replace(self, old, new, count=-1, /)\n",
      " |      Return a copy with all occurrences of substring old replaced by new.\n",
      " |      \n",
      " |        count\n",
      " |          Maximum number of occurrences to replace.\n",
      " |          -1 (the default value) means replace all occurrences.\n",
      " |      \n",
      " |      If the optional argument count is given, only the first count occurrences are\n",
      " |      replaced.\n",
      " |  \n",
      " |  rfind(...)\n",
      " |      S.rfind(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  rindex(...)\n",
      " |      S.rindex(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  rjust(self, width, fillchar=' ', /)\n",
      " |      Return a right-justified string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  rpartition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |      \n",
      " |      This will search for the separator in the string, starting at the end. If\n",
      " |      the separator is found, returns a 3-tuple containing the part before the\n",
      " |      separator, the separator itself, and the part after it.\n",
      " |      \n",
      " |      If the separator is not found, returns a 3-tuple containing two empty strings\n",
      " |      and the original string.\n",
      " |  \n",
      " |  rsplit(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the words in the string, using sep as the delimiter string.\n",
      " |      \n",
      " |        sep\n",
      " |          The delimiter according which to split the string.\n",
      " |          None (the default value) means split according to any whitespace,\n",
      " |          and discard empty strings from the result.\n",
      " |        maxsplit\n",
      " |          Maximum number of splits to do.\n",
      " |          -1 (the default value) means no limit.\n",
      " |      \n",
      " |      Splits are done starting at the end of the string and working to the front.\n",
      " |  \n",
      " |  rstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with trailing whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  split(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the words in the string, using sep as the delimiter string.\n",
      " |      \n",
      " |      sep\n",
      " |        The delimiter according which to split the string.\n",
      " |        None (the default value) means split according to any whitespace,\n",
      " |        and discard empty strings from the result.\n",
      " |      maxsplit\n",
      " |        Maximum number of splits to do.\n",
      " |        -1 (the default value) means no limit.\n",
      " |  \n",
      " |  splitlines(self, /, keepends=False)\n",
      " |      Return a list of the lines in the string, breaking at line boundaries.\n",
      " |      \n",
      " |      Line breaks are not included in the resulting list unless keepends is given and\n",
      " |      true.\n",
      " |  \n",
      " |  startswith(...)\n",
      " |      S.startswith(prefix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S starts with the specified prefix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      prefix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  strip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading and trailing whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  swapcase(self, /)\n",
      " |      Convert uppercase characters to lowercase and lowercase characters to uppercase.\n",
      " |  \n",
      " |  title(self, /)\n",
      " |      Return a version of the string where each word is titlecased.\n",
      " |      \n",
      " |      More specifically, words start with uppercased characters and all remaining\n",
      " |      cased characters have lower case.\n",
      " |  \n",
      " |  translate(self, table, /)\n",
      " |      Replace each character in the string using the given translation table.\n",
      " |      \n",
      " |        table\n",
      " |          Translation table, which must be a mapping of Unicode ordinals to\n",
      " |          Unicode ordinals, strings, or None.\n",
      " |      \n",
      " |      The table must implement lookup/indexing via __getitem__, for instance a\n",
      " |      dictionary or list.  If this operation raises LookupError, the character is\n",
      " |      left untouched.  Characters mapped to None are deleted.\n",
      " |  \n",
      " |  upper(self, /)\n",
      " |      Return a copy of the string converted to uppercase.\n",
      " |  \n",
      " |  zfill(self, width, /)\n",
      " |      Pad a numeric string with zeros on the left, to fill a field of the given width.\n",
      " |      \n",
      " |      The string is never truncated.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  maketrans(...)\n",
      " |      Return a translation table usable for str.translate().\n",
      " |      \n",
      " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
      " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      " |      Character keys will be then converted to ordinals.\n",
      " |      If there are two arguments, they must be strings of equal length, and\n",
      " |      in the resulting dictionary, each character in x will be mapped to the\n",
      " |      character at the same position in y. If there is a third argument, it\n",
      " |      must be a string, whose characters will be mapped to None in the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Second excersise in presentation: using functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write code that does the following:\n",
    "1. Makes a list of the words from the bases string\n",
    "2. Converts them all into uppercase\n",
    "3. Reverses their order\n",
    "4. (Bonus) Print the first letter from each word\n",
    "\n",
    "**Hint:** Use the `help()` function on `str` and `list` to see what methods are available to assist with the task. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "bases = 'adenine cytosine guanine thymine'\n",
    "# Your code here!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've already written code that performs basic operations on DNA sequences: reverse complement and calculating GC content percentage. But that code only runs on our example `seq`, and it would be more useful if we could 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 short function\n",
    "\n",
    "- Start with `def`, a keyword meaning we define a function\n",
    "- Give it a name, in this case **double**\n",
    "    - Use a descriptive name that indicates what the function does\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",
    "- Use the `return` keyword to return values from the function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "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": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "doubled_value = double(100)\n",
    "print(doubled_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if someone wants to know what your function does? Let's try using `help()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function double in module __main__:\n",
      "\n",
      "double(x)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(double)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the message given does not actually say anything about what it does. You can write a description about your function to help others read and understand your code using what is called a **docstring**. This is a string that you add right after the `def` statement as the first line in the code block. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function double in module __main__:\n",
      "\n",
      "double(x)\n",
      "    Takes a value and doubles it\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def double(x):\n",
    "    \"Takes a value and doubles it\"\n",
    "    result = x * 2\n",
    "    return result\n",
    "help(double)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will cover docstrings and how to format them in a later lesson. For now, just remember that you can (**and should**) write documentation to help yourself and others use functions you wrote. "
   ]
  },
  {
   "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": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse(seq):\n",
    "    \"Returns the reverse of a sequence\"\n",
    "    rev = ''\n",
    "    for s in seq:\n",
    "        rev = s + rev\n",
    "    return rev\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GTCA\n"
     ]
    }
   ],
   "source": [
    "print(reverse('ACTG'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCTGCATGC\n",
      "CGTACGTCCA\n"
     ]
    }
   ],
   "source": [
    "print(seq)\n",
    "print(reverse(seq))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To test that the function works, we could:\n",
    "- see if the output is correct ourselves\n",
    "- test that double-reversing gives us the original sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ACCTGCATGC'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse(reverse(seq))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse(reverse(seq)) == seq"
   ]
  },
  {
   "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": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "def complement(seq):\n",
    "    \"Switches all A and T characters. Switches all G and C characters\"\n",
    "    comp = ''\n",
    "    for s in seq:\n",
    "        c = comps[s]\n",
    "        comp = comp + c\n",
    "    return comp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACCTGCATGC\n",
      "TGGACGTACG\n"
     ]
    }
   ],
   "source": [
    "print(seq)\n",
    "print(complement(seq))"
   ]
  },
  {
   "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 `comps`, the function will fail\n",
    "2. If we run it with `comps` 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": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def complement(seq):\n",
    "    \"Switches all A and T characters. Switches all G and C characters\"\n",
    "    comps = {'A': 'T', 'C': 'G', 'T': 'A', 'G': 'C'}\n",
    "    comp = ''\n",
    "    for s in seq:\n",
    "        c = comps[s]\n",
    "        comp = comp + c\n",
    "    return comp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TGG'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complement('ACC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TGG'"
      ]
     },
     "execution_count": 81,
     "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": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse_complement(seq):\n",
    "    \"Reverses the complement of a sequence\"\n",
    "    return reverse(complement(seq))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TTGG'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse_complement('CCAA')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Third excersise in presentation: update the reverse function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Update the `reverse()` function to use splicing instead of a loop. With splicing, this can be done by making the step argument -1. Recall that the format for splicing is [start:end:step]. \n",
    "\n",
    "Afterwards, run the `reverse_complement()` function on the given sequence. Do you have to make any chances to the `complement()` or `reverse_complement()` functions written before?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TTGG'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Update this!\n",
    "def reverse(seq):\n",
    "    \"Returns the reverse of a sequence\"\n",
    "    rev = ''\n",
    "    for s in seq:\n",
    "        rev = s + rev\n",
    "    return rev\n",
    "\n",
    "# Write any additional code here (if needed)\n",
    "\n",
    "\n",
    "# Does this behave the same after the update?\n",
    "reverse_complement(\"CCAA\")"
   ]
  },
  {
   "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 are libraries 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": 85,
   "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": [
    "Let's go through the steps we just did.\n",
    "\n",
    "1. We used the `open()` **function** on a string that represents a path to a file.\n",
    " - The result of that function was saved to the variable `f`. This value is called a **file object**.\n",
    "2. We wrote a for loop. When you write a for loop for a file object, each loop variable represents a line in the file. \n",
    "3. We printed the loop variable for each loop. \n",
    "4. We used the **method** `.close()` to close the file. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading lines\n",
    "\n",
    "When we work with text files, we can 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. Text files and programs indicate that there is a new line using a special newline character, `\\n`. In our previous example, each line in the file includes the `\\n` newline character at the end.\n",
    "\n",
    "Let's look into this by adding each line to a single string, all_lines, and compare printing the string vs the raw data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "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",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'>lcl|AE014075.1_gene_2 [locus_tag=c0002] [location=534..911]\\nGTGTTCTACAGAGAGAAGCGTAGAGCAATAGGCTGTATTTTGAGAAAGCTGTGTGAGTGGAAAAGTGTAC\\nGGATTCTGGAAGCTGAATGCTGTGCAGATCATATCCATATGCTTGTGGAGATCCCGCCCAAAATGAGCGT\\nATCAGGCTTTATGGGATATCTGAAAGGGAAAAGCAGTCTGATGCCTTACGAGCAGTTTGGTGATTTGAAA\\nTTCAAATACAGGAACAGGGAGTTCTGGTGCAGAGGGTATTACGTCGATACGGTGGGTAAGAACACGGCGA\\n\\n'"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = open('ae.fa')\n",
    "all_lines = ''\n",
    "for line in f:\n",
    "    all_lines = all_lines + line\n",
    "f.close()\n",
    "print(all_lines) # First output is the print result\n",
    "all_lines # Second is what the string data looks like"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we know we have the whole line, we can strip off the newline character with the `.strip()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'There is a newline at the end\\n'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_with_newline = \"There is a newline at the end\\n\"\n",
    "string_with_newline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'There is a newline at the end'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_with_newline.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try this with our original code to print each line in a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "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": [
    "### Fourth excersise in presentation: reading a fasta file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function called `read_fasta(filename)` that takes in the input filename and returns a single string for all of the DNA sequences in the file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Your code here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(read_fasta('ae.fa'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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_fasta` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`$ nano read_fasta.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with a script that reads the ae.fa file specifically and prints it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the first line contains a `%%` operator followed by the command writefile and a file name. This operator is specific to jupyter notebooks, called a \"Cell Magic Command\", and copies the code written in a cell into a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile read_fasta_v1.py\n",
    "def read_fasta(filename):\n",
    "    \"Reads a fasta file and returns all sequences concatenated\"\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": "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 module called `sys` from the standard library, a collection of modules included in python but not available by default. The documentation for these is part of the documentation for python: https://docs.python.org/3/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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile read_fasta_v2.py\n",
    "import sys\n",
    "\n",
    "def read_fasta(filename):\n",
    "    \"Reads a fasta file and returns all sequences concatenated\"\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": "markdown",
   "metadata": {},
   "source": [
    "But what happens if we don't have an input file name? According to the documentation, sys.argv, returns a list where the first item sys.argv[0] is the name of the script by default, and each additional item in the list are the command line arguments. If no argument was passed, sys.argv should be a list of just the script name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile read_fasta_v3.py\n",
    "import sys\n",
    "\n",
    "def read_fasta(filename):\n",
    "    \"Reads a fasta file and returns all sequences concatenated\"\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",
    "    sys.exit(1)\n",
    "\n",
    "print(read_fasta(sys.argv[1]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary slide in presentation"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}