Introduction_to_python_week_1_session_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# An introduction to solving biological problems with Python\n",
    "\n",
    "## Week 1 - Session 2: Collections\n",
    "\n",
    "- [Lists](#Lists) and [Manipulating lists](#Manipulating-lists) | [Exercise 1.2.1](#Exercise-1.2.1)\n",
    "- [String manipulations](#String-manipulations) | [Exercise 1.2.2](#Exercise-1.2.2)\n",
    "- [Dictionaries](#Dictionaries) | [Exercises 1.2.3](#Exercises-1.2.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As well as the basic data types we introduced above, very commonly you will want to store and operate on collections of values, and python has several _data structures_ that you can use to do this. The general idea is that you can place several items into a single collection and then refer to that collection as a whole. Which one you will use will depend on what problem you are trying to solve.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "- Can contain any number of items\n",
    "- Can contain different types of items\n",
    "- __Can__ be altered once created (they are _mutable_)\n",
    "- Items have a particular order\n",
    "\n",
    "Lists are created with square brackets around their items:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 9]\n",
      "['ATG']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 3, 9]\n",
    "b = [\"ATG\"]\n",
    "c = []\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can contain other lists, or any other type of collection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 0], [0, 2]]\n"
     ]
    }
   ],
   "source": [
    "matrix = [[1, 0], [0, 2]]\n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulating lists\n",
    "\n",
    "Once your data is in a list, python supports a number of ways you can access elements of the list and manipulate the list in useful ways, such as sorting the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index access\n",
    "\n",
    "You can access individual elements of the collection using their _index_, note that the first element is at index 0. Negative indices count backwards from the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is [123, 54, 92, 87, 33]\n",
      "x[-1] is 33\n"
     ]
    }
   ],
   "source": [
    "x = [123, 54, 92, 87, 33]\n",
    "\n",
    "print('x is', x)\n",
    "print('x[-1] is', x[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slices\n",
    "\n",
    "You can also access a range of items, known as _slices_, from inside lists using a colon `:` to indicate the beginning and end of the slice inside the square brackets. **Note that the slice notation `[a:b]` includes positions from `a` up to _but not including_ `b`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x[2:] is [92, 87, 33]\n",
      "x[:-1] is [123, 54, 92, 87]\n"
     ]
    }
   ],
   "source": [
    "x = [123, 54, 92, 87, 33]\n",
    "print('x[2:] is', x[2:])\n",
    "print('x[:-1] is', x[:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `in` operator\n",
    "You can check if a value is in a list with the <tt>in</tt> operator, and you can negate this with <tt>not</tt>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123 in [123, 54, 92, 87, 33] True\n",
      "999 not in [123, 54, 92, 87, 33] True\n"
     ]
    }
   ],
   "source": [
    "x = [123, 54, 92, 87, 33]\n",
    "print('123 in', x, 123 in x)\n",
    "print('999 not in', x, 999 not in x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `len()` and `count()` functions\n",
    "You can get the length of a list with the in-built <tt>len()</tt> function, and you can count the number of particular elements contained in a list with the <tt>.count()</tt> function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of 33s in x is 1\n"
     ]
    }
   ],
   "source": [
    "x = [123, 54, 92, 87, 33]\n",
    "print(\"number of 33s in x is\", x.count(33))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying lists\n",
    "You can alter lists in place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[123, 54, 92, 87, 33]\n",
      "[123, 54, 33, 87, 33]\n"
     ]
    }
   ],
   "source": [
    "x = [123, 54, 92, 87, 33]\n",
    "print(x)\n",
    "x[2] = 33\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add elements to the end of a list with <tt>append()</tt>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[123, 54, 92, 87, 33, 101]\n"
     ]
    }
   ],
   "source": [
    "x = [123, 54, 92, 87, 33]\n",
    "x.append(101)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or insert values at a certain position with <tt>insert()</tt>, by supplying the desired position as well as the new value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[123, 54, 92, 1111, 87, 33]\n"
     ]
    }
   ],
   "source": [
    "x = [123, 54, 92, 87, 33]\n",
    "x.insert(3, 1111)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can remove values with <tt>remove()</tt>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[54, 92, 87, 33]\n"
     ]
    }
   ],
   "source": [
    "x = [123, 54, 92, 87, 33]\n",
    "x.remove(123)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and delete values by index with <tt>del</tt>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[123, 54, 92, 87, 33]\n",
      "[54, 92, 87, 33]\n"
     ]
    }
   ],
   "source": [
    "x = [123, 54, 92, 87, 33]\n",
    "print(x)\n",
    "del x[0]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's often useful to be able to combine arrays together, which can be done with <tt>extend()</tt> (as <tt>append</tt> would add the whole list as a single element in the list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[1, 2, 3, 4, 5, 6, [4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = [4,5,6]\n",
    "a.extend(b)\n",
    "print(a)\n",
    "a.append(b)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plus symbol <tt>+</tt> is shorthand for the extend operation when applied to lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "a = a + b\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slice syntax can be used on the left hand side of an assignment operation to assign subregions of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 9, 9, 9, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 4, 5, 6]\n",
    "a[1:3] = [9, 9, 9, 9]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change the order of elements in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 5, 3, 1]\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 3, 5, 4, 2]\n",
    "a.reverse()\n",
    "print(a)\n",
    "a.sort()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that both of these change the list, if you want a sorted copy of the list while leaving the original untouched, use <tt>sorted()</tt>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 5, 7, 1]\n",
      "[1, 2, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "a = [2, 5, 7, 1]\n",
    "b = sorted(a)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.2.1\n",
    "\n",
    "1. Create a list of DNA codons for the protein sequence CLYSY based on the codon variables you defined previously.\n",
    "2. Print the DNA sequence of the protein to the screen.\n",
    "3. Print the DNA codon of the last amino acid in the protein sequence.\n",
    "4. Create two more variables containing the DNA sequence of a stop codon and a start codon, and replace the first element of the DNA sequence with the start codon and append the stop codon to the end of the DNA sequence. Print out the resulting DNA sequence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String manipulations\n",
    "\n",
    "Strings can be accessed and manipulated using similar operations we introduced above.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "G\n",
      "ATGTCA\n",
      "True\n",
      "False\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "text = \"ATGTCATTTGT\"\n",
    "print(text[0])\n",
    "print(text[-2])\n",
    "print(text[0:6])\n",
    "print(\"ATG\" in text)\n",
    "print(\"TGA\" in text)\n",
    "print(len(text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trying to assign a value to an element of a string results in an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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)",
      "\u001b[0;32m<ipython-input-36-a34610df3f4b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtext\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"ATGTCATTTGT\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtext\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\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\"CCC\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "text = \"ATGTCATTTGT\"\n",
    "text[0:2] = \"CCC\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides a number of useful functions that let you manipulate strings\n",
    "\n",
    "The <tt>in</tt> operator lets you check if a substring is contained within a larger string, but it does not tell you where the substring is located. This is often useful to know and python provides the <tt>.find()</tt> method which returns the index of the first occurrence of the search string, and the <tt>.rfind()</tt> method to start searching from the end of the string.\n",
    "\n",
    "If the search string is not found in the string both these methods return -1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TCA is at position: 3\n",
      "The last Cytosine is at position: 7\n",
      "Position of a stop codon: -1\n"
     ]
    }
   ],
   "source": [
    "dna = \"ATGTCACCGTTT\"\n",
    "index = dna.find(\"TCA\")\n",
    "print(\"TCA is at position:\", index)\n",
    "index = dna.rfind('C')\n",
    "print(\"The last Cytosine is at position:\", index)\n",
    "print(\"Position of a stop codon:\", dna.find(\"TGA\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we are reading text from files  (which we will see later on), often there is unwanted whitespace at the start or end of the string. We can remove leading whitespace with the <tt>.lstrip()</tt> method, trailing whitespace with <tt>.rstrip()</tt>, and whitespace from both ends with <tt>.strip()</tt>.\n",
    "\n",
    "All of these methods return a copy of the changed string, so if you want to replace the original you can assign the result of the method call to the original variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45     Chromosome Start End                     \n",
      "41 Chromosome Start End                     \n",
      "20 Chromosome Start End\n",
      "20 Chromosome Start End\n"
     ]
    }
   ],
   "source": [
    "s = \"    Chromosome Start End                     \"\n",
    "print(len(s), s)\n",
    "s = s.lstrip()\n",
    "print(len(s), s)\n",
    "s = s.rstrip()\n",
    "print(len(s), s)\n",
    "s = \"    Chromosome Start End                     \"\n",
    "s = s.strip()\n",
    "print(len(s), s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can split a string into a list of substrings using the <tt>.split()</tt> method, supplying the delimiter as an argument to the method. If you don't supply any delimiter the method will split the string on whitespace by default (which is very often what you want!)\n",
    "\n",
    "To split a string into its component characters you can simply _cast_ the string to a list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ATG', 'TCA', 'CCG', 'GGC']\n",
      "['A', 'T', 'G', ' ', 'T', 'C', 'A', ' ', 'C', 'C', 'G', ' ', 'G', 'G', 'C']\n"
     ]
    }
   ],
   "source": [
    "seq = \"ATG TCA CCG GGC\"\n",
    "codons = seq.split(\" \")\n",
    "print(codons)\n",
    "\n",
    "bases = list(seq)\n",
    "print(bases)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<tt>.split()</tt> is the counterpart to the <tt>.join()</tt> method that lets you join the elements of a list into a string only if all the elements are of type String:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ATG', 'TCA', 'CCG', 'GGC']\n",
      "ATG|TCA|CCG|GGC\n"
     ]
    }
   ],
   "source": [
    "seq = \"ATG TCA CCG GGC\"\n",
    "codons = seq.split(\" \")\n",
    "print(codons)\n",
    "print(\"|\".join(codons))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also saw earlier that the <tt>+</tt> operator lets you concatenate strings together into a larger string.\n",
    "\n",
    "Note that this operator only works on variables of the same type. If you want to concatenate a string with an integer (or some other type), first you have to cast the integer to a string with the <tt>str()</tt> function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chr2\n"
     ]
    }
   ],
   "source": [
    "s = \"chr\"\n",
    "chrom_number = 2\n",
    "print(s + str(chrom_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.2.2\n",
    "\n",
    "1. Create a string variable with your full name in it, with your first and last name (and any middle names) seperated by a space. Split the string into a list, and print out your surname.\n",
    "2. Check if your surname contains the letter \"E\", and print out the position of this letter in the string. Try a few other letters.\n",
    "\n",
    "### Optional exercise\n",
    "- Use a format string to print out your first name and the length of your first name by looking into the python library for String formating https://docs.python.org/3/library/stdtypes.html#str.format and https://docs.python.org/3/library/string.html#formatstrings using `str.format()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "Lists are useful in many contexts, but often we have some data that has no inherent order and that we want to access by some useful name rather than an index. For example, as a result of some experiment we may have a set of genes and corresponding expression values. We could put the expression values in a list, but then we'd have to remember which index in the list corresponded to which gene and this would quickly get complicated.\n",
    "\n",
    "For these situations a _dictionary_ is a very useful data structure.\n",
    "\n",
    "Dictionaries:\n",
    "\n",
    "- Contain a mapping of keys to values (like a word and its corresponding definition in a dictionary)\n",
    "- The keys of a dictionary are unique, i.e. they cannot repeat\n",
    "- Dictionaries do not store data in any particular order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 'Adenine', 'C': 'Cytosine', 'G': 'Guanine', 'T': 'Thymine'}\n"
     ]
    }
   ],
   "source": [
    "dna = {\"A\": \"Adenine\", \"C\": \"Cytosine\", \"G\": \"Guanine\", \"T\": \"Thymine\"}\n",
    "print(dna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access values in a dictionary using the key inside square brackets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A represents Adenine\n",
      "G represents Guanine\n"
     ]
    }
   ],
   "source": [
    "dna = {\"A\": \"Adenine\", \"C\": \"Cytosine\", \"G\": \"Guanine\", \"T\": \"Thymine\"}\n",
    "print(\"A represents\", dna[\"A\"])\n",
    "print(\"G represents\", dna[\"G\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An error is triggered if a key is absent from the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'N'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-44-8300010def4c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mdna\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"A\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"Adenine\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"C\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"Cytosine\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"G\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"Guanine\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"T\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"Thymine\"\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"What about N?\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdna\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"N\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'N'"
     ]
    }
   ],
   "source": [
    "dna = {\"A\": \"Adenine\", \"C\": \"Cytosine\", \"G\": \"Guanine\", \"T\": \"Thymine\"}\n",
    "print(\"What about N?\", dna[\"N\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access values safely with the <tt>get</tt> method, which gives back <tt>None</tt> if the key is absent and you can also supply a default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What about N? None\n",
      "With a default value: unknown\n"
     ]
    }
   ],
   "source": [
    "dna = {\"A\": \"Adenine\", \"C\": \"Cytosine\", \"G\": \"Guanine\", \"T\": \"Thymine\"}\n",
    "print(\"What about N?\", dna.get(\"N\"))\n",
    "print(\"With a default value:\", dna.get(\"N\", \"unknown\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check if a key is in a dictionary with the <tt>in</tt> operator, and you can negate this with <tt>not</tt>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dna = {\"A\": \"Adenine\", \"C\": \"Cytosine\", \"G\": \"Guanine\", \"T\": \"Thymine\"}\n",
    "\"T\" in dna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dna = {\"A\": \"Adenine\", \"C\": \"Cytosine\", \"G\": \"Guanine\", \"T\": \"Thymine\"}\n",
    "\"Y\" not in dna"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <tt>len()</tt> function gives back the number of (key, value) pairs in the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "dna = {\"A\": \"Adenine\", \"C\": \"Cytosine\", \"G\": \"Guanine\", \"T\": \"Thymine\"}\n",
    "print(len(dna))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can introduce new entries in the dictionary by assigning a value with a new key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 'Adenine', 'C': 'Cytosine', 'G': 'Guanine', 'T': 'Thymine', 'Y': 'Pyrimidine'}\n"
     ]
    }
   ],
   "source": [
    "dna = {\"A\": \"Adenine\", \"C\": \"Cytosine\", \"G\": \"Guanine\", \"T\": \"Thymine\"}\n",
    "dna['Y'] = 'Pyrimidine'\n",
    "print(dna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change the value for an existing key by reassigning it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 'Adenine', 'C': 'Cytosine', 'T': 'Thymine', 'G': 'Guanine', 'Y': 'Cytosine or Thymine'}\n"
     ]
    }
   ],
   "source": [
    "dna = {'A': 'Adenine', 'C': 'Cytosine', 'T': 'Thymine', 'G': 'Guanine', 'Y': 'Pyrimidine'}\n",
    "dna['Y'] = 'Cytosine or Thymine'\n",
    "print(dna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can delete entries from the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 'Adenine', 'C': 'Cytosine', 'T': 'Thymine', 'G': 'Guanine'}\n"
     ]
    }
   ],
   "source": [
    "dna = {'A': 'Adenine', 'C': 'Cytosine', 'T': 'Thymine', 'G': 'Guanine', 'Y': 'Pyrimidine'}\n",
    "del dna['Y']\n",
    "print(dna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get a list of all the keys (in arbitrary order) using the inbuilt <tt>.keys()</tt> function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'C', 'T', 'G', 'Y']\n"
     ]
    }
   ],
   "source": [
    "dna = {'A': 'Adenine', 'C': 'Cytosine', 'T': 'Thymine', 'G': 'Guanine', 'Y': 'Pyrimidine'}\n",
    "print(list(dna.keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And equivalently get a list of the values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Adenine', 'Cytosine', 'Thymine', 'Guanine', 'Pyrimidine']\n"
     ]
    }
   ],
   "source": [
    "dna = {'A': 'Adenine', 'C': 'Cytosine', 'T': 'Thymine', 'G': 'Guanine', 'Y': 'Pyrimidine'}\n",
    "print(list(dna.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And a list containing (key, value) pairs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('A', 'Adenine'), ('C', 'Cytosine'), ('T', 'Thymine'), ('G', 'Guanine'), ('Y', 'Pyrimidine')]\n"
     ]
    }
   ],
   "source": [
    "dna = {'A': 'Adenine', 'C': 'Cytosine', 'T': 'Thymine', 'G': 'Guanine', 'Y': 'Pyrimidine'}\n",
    "print(list(dna.items()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises 1.2.3\n",
    "\n",
    "1. Print out the names of the amino acids that would be produced by the DNA sequence \"GTT GCA CCA CAA CCG\" ([See the DNA codon table](https://en.wikipedia.org/wiki/DNA_codon_table)). Split this string into the individual codons and then use a dictionary to map between codon sequences and the amino acids they encode.\n",
    "2. Print each codon and its corresponding amino acid.\n",
    "3. Why couldn't we build a dictionary where the keys are names of amino acids and the values are the DNA codons?\n",
    "\n",
    "### Advanced exercise\n",
    "\n",
    "- Starting with an empty dictionary, count the abundance of different residue types present in the 1-letter lysozyme protein sequence (http://www.uniprot.org/uniprot/B2R4C5.fasta) and print the results to the screen in alphabetical key order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Congratulations! You reached the end of Week 1! \n",
    "\n",
    "Go to our next notebook: [Introduction_to_python_week_2_session_1](Introduction_to_python_week_2_session_1.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}