lectures/lecture09/lecture09.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 08 and 09: Practical analyses in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "Python defines a powerful type called a dictionary or `dict`.\n",
    "\n",
    "### Mutable versus immutable types\n",
    "Before using dictionaries, we need to understand the difference between [mutable and immutable types](https://medium.com/@meghamohan/mutable-and-immutable-side-of-python-c2145cf72747).\n",
    "\n",
    "Let's review the types we've learned so far:\n",
    "#### Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_int = 1\n",
    "\n",
    "type(x_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An integer is immutable, we can't change it's value by reassigment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_int = x_int\n",
    "y_int += 1\n",
    "print(f\"y_int = {y_int}, x = {x_int}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_float = 3.7\n",
    "\n",
    "type(x_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Floats are also immutable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_float = x_float\n",
    "y_float += 1\n",
    "print(f\"y_float = {y_float}, x = {x_float}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_list = [1, 2, 3]\n",
    "\n",
    "type(x_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But lists are mutable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_list = x_list\n",
    "y_list.append(4)\n",
    "\n",
    "print(f\"y_list = {y_list}, x_list = {x_list}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the value of `x_list` has changed too! Lists are mutable, meaning they point to the mutable object, not to its value.\n",
    "Be careful with mutable objects!\n",
    "\n",
    "There is an immutable object that has some similar properties to a list called a `tuple`, but we aren't going to go into those right now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_str = 'hello'\n",
    "\n",
    "type(x_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are immutable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_str = x_str\n",
    "y_str += ' friend'\n",
    "\n",
    "print(f\"y_str = {y_str}, x_str = {x_str}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is a dictionary?\n",
    "Dictionaries are \"look up tables\" that can be used to map keys to values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_dict = {'best_teacher': 'Jesse',\n",
    "                'worst_teacher': 'Rasi'}\n",
    "\n",
    "teacher_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This dictionary maps the best and worst teachers to their names.\n",
    "We can look up the value for a key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_dict['best_teacher']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we get an error if they key doesn't exist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "teacher_dict['second_best_teacher']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get all of the keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_dict.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or the values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_dict.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or the items, which are tuples with keys and values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_dict.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add entries to a dictionary like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_dict['most_fashionable_teacher'] = 'Trevor'\n",
    "\n",
    "teacher_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the above cell shows that dictionaries are mutable, as we changed the dictionary by adding to it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An advantage of a dictionary is that it is very fast to look up key / value pairs even if there are lots of entries in the dictionary.\n",
    "\n",
    "So why did I make a big deal about mutable versus immutable?\n",
    "Dictionary keys can **only** be immutable. \n",
    "So keying a dictionary with a mutable type (such as a `list`) is not allowed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "teacher_dict[['previous_teacher', 'current_teacher']] = [['Erick', 'Jesse']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But dictionary values can be mutable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_dict['previous_and_current_teachers'] = [['Erick', 'Jesse']]\n",
    "\n",
    "teacher_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using a dictionary in a function\n",
    "Now we will use a dictionary to implement a function that gets the reverse complement of a sequence.\n",
    "\n",
    "Here is the desired signature of the function. Can you write this function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse_complement(seq):\n",
    "    \"\"\"Get reverse complement of a DNA sequence.\n",
    "    \n",
    "    Parameters\n",
    "    -----------\n",
    "    seq : str\n",
    "        Uppercase DNA sequence.\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    str\n",
    "        Reverse complement of the sequence in upper case.\n",
    "        \n",
    "    Example\n",
    "    --------\n",
    "    >>> reverse_complement('ATGCAC')\n",
    "    'GTGCAT'\n",
    "    \n",
    "    \"\"\"\n",
    "    rc_dict = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G', 'N': 'N'}\n",
    "    revcomplement = []\n",
    "    for nt in reversed(seq.upper()):\n",
    "        revcomplement.append(rc_dict[nt])\n",
    "    return ''.join(revcomplement)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the function is written, you can use it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reverse_complement('ATGCAC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reverse_complement('aTGCTAAAAGTTCAGGATACAGGTAAN')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regular expressions\n",
    "The `re` module is for \"regular expressions\". \n",
    "These are very useful for parsing strings.\n",
    "\n",
    "Here is a common example from my work with influenza.\n",
    "You download some strains from the database, and they have names that look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "strain1 = 'A/New York/3/1994 (H3N2)'\n",
    "strain2 = 'A/California/3/X/2003 (H12N1)'\n",
    "strain3 = 'A/Perth/2009 (H3N2)'\n",
    "\n",
    "strains = [strain1, strain2, strain3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You want to get some information out of these, like the year.\n",
    "\n",
    "Regular expressions allow you to define patterns in a string.\n",
    "Here we build a regular expression that gets the subtype out and then use a dictionary to count how many sequences there are of each subtype:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "# regular expression that gets year and subtype\n",
    "strainmatch = re.compile(\n",
    "        '(?P<year>\\d{4}) \\((?P<subtype>H\\d+N\\d+)\\)$')\n",
    "\n",
    "subtype_counter = {}  # dict to store the results\n",
    "\n",
    "for strain in strains:  # loop over all strains\n",
    "    m = strainmatch.search(strain)\n",
    "    year = m.group('year')\n",
    "    subtype = m.group('subtype')\n",
    "    if subtype in subtype_counter:\n",
    "        subtype_counter[subtype] += 1\n",
    "    else:\n",
    "        subtype_counter[subtype] = 1\n",
    "        \n",
    "print(subtype_counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are lots of handy special codes in the Python regular expression module (see [here](https://docs.python.org/3.7/library/re.html)), and you can use them to do almost any type of string matching."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using regular expressions to parse barcodes\n",
    "Now we will use regular expressions to parse barcodes from nucleotide sequences.\n",
    "For instance, you might have to do this in a single-cell RNA-seq experiment where there is a barcode at the end of each read telling you the cell that the read came from.\n",
    "\n",
    "Imagine that our valid molecules should have sequences like this:\n",
    "\n",
    "`CTAGCNNNNNNGATCA`\n",
    "\n",
    "See how there is a 6-nucleotide barcode in the center of the sequence.\n",
    "We have a list of sequences, and want to parse through them to figure out which ones meet the expected pattern--and get the barcode from those that do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seqs = ['CTAGCatcgatGATCA',  # has barcode ATCGAT\n",
    "        'CCAGCatagcaGATCA',  # does not have expected 5' sequence\n",
    "        'CTAGCtacagGATCA',   # barcode too short\n",
    "        'CTAGCgaccatGATCA',  # has barcode GACCAT\n",
    "        'CTAGCatcgatGATCA',  # has barcode ATCGAT\n",
    "        'CTAGCatcgatGGTCA',  # does not have expected 3' sequence\n",
    "        ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that parses these barcoded sequences and gets the ones with valid barcodes.\n",
    "In doing this, note that:\n",
    "\n",
    "  1. If you have a string `s`, `s.upper()` makes it all uppercase.\n",
    "  2. Consider using the following regular expression options (all described [here](https://docs.python.org/3.7/library/re.html):\n",
    "    - `[]` indicates a set of characters.\n",
    "    - `{n}` indicates number of occurrences.\n",
    "    - `(?P<name>)` indicates a group with name `name`.\n",
    "    - The `match` method finds a match at the beginning of the string.\n",
    "    \n",
    "Below I've written the function documentation, try to implement it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_barcodes(seqs, bclen=6, upstream='CTAGC', downstream='GATCA'):\n",
    "    \"\"\"Parse and count barcodes.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    seqs : list\n",
    "        DNA sequences.\n",
    "    bclen : int\n",
    "        Length of barcode\n",
    "    upstream : str\n",
    "        Sequence upstream of barcode.\n",
    "    downstream : str\n",
    "        Sequence downstream of barcode.\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    dict\n",
    "        Keyed by each valid barcode, value is number of times the barcode\n",
    "        is observed.\n",
    "        \n",
    "    Note\n",
    "    ----\n",
    "    The function is **not** case-sensitive, and all barcodes are reported\n",
    "    in upper-case.\n",
    "    \n",
    "    \"\"\"\n",
    "    regex = re.compile(upstream +\n",
    "                       f\"(?P<bc>[ACGT]{{{bclen}}})\" +\n",
    "                       downstream\n",
    "                       )\n",
    "    counts = {}\n",
    "    for seq in seqs:\n",
    "        seq = seq.upper()\n",
    "        m = regex.match(seq)\n",
    "        if m:\n",
    "            bc = m.group('bc')\n",
    "            if bc in counts:\n",
    "                counts[bc] += 1\n",
    "            else:\n",
    "                counts[bc] = 1\n",
    "    return counts\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the function once you've implemented it. Does it give the right result?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count_barcodes(seqs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Biopython\n",
    "[Biopython](https://biopython.org/) is a package that has lots of useful functions for computational biology.\n",
    "\n",
    "It is very handy for things like reading in sequences in many different formats: [Bio.SeqIO](https://biopython.org/wiki/SeqIO) is your friend!\n",
    "\n",
    "(Do note that if you are analyzing truly large datasets, `Biopython` is not very fast and you may want to use something like [pysam](https://pysam.readthedocs.io/en/latest/api.html); but `Biopython` is a good starting point).\n",
    "\n",
    "### Reading in a file\n",
    "I have included the file [barcodes_R1.fastq](barcodes_R1.fastq), which has some FASTQ sequences in it.\n",
    "\n",
    "First, let's just see what the beginning of that file looks like (FASTQ format is explained in detail [here](https://en.wikipedia.org/wiki/FASTQ_format)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! head -n 8 barcodes_R1.fastq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's use `Biopython` to read the FASTQ entries.\n",
    "\n",
    "First, import `Biopython.SeqIO`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "import Bio.SeqIO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now read in the sequencing reads:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seqreads = list(Bio.SeqIO.parse('barcodes_R1.fastq', format='fastq'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many reads were there?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Found {len(seqreads)} sequencing reads.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the first read:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seqreads[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that `BioPython` reads the sequences in as [SeqRecord](https://biopython.org/wiki/SeqRecord) objects, which have a lot of information, including the header, quality scores, etc.\n",
    "\n",
    "For our purposes, we will just convert the sequence part into a string for each sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seqreads_str = [str(s.seq) for s in seqreads]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the above cell used a [list comprehension](https://www.pythonforbeginners.com/basics/list-comprehensions-in-python).\n",
    "Write the same code as a for loop and verify that it gives the same result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seqreads_str_2 = []\n",
    "for seqrecord in seqreads:\n",
    "    seqreads_str_2.append(str(seqrecord.seq))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make sure `seqreads_str` and `seqreads_str_2` have all identical entries\n",
    "assert len(seqreads_str) == len(seqreads_str_2)\n",
    "for i in range(len(seqreads_str)):\n",
    "    s1 = seqreads_str[i]\n",
    "    s2 = seqreads_str_2[i]\n",
    "    assert s1 == s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure we still have the same number of sequencing reads, and look at the first one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert len(seqreads_str) == len(seqreads)\n",
    "\n",
    "seqreads_str[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A real biological analysis: parsing barcodes\n",
    "<a id='real_analysis'></a>\n",
    "The reads that we just read as `seqreads_str` come from a real sequencing run of influenza virus HA and NA genes.\n",
    "\n",
    "The sequences are as follows:\n",
    "\n",
    "    5'-[end of HA]-AGGCGGCCGC-[16 X N]-3'\n",
    "    \n",
    "or \n",
    "\n",
    "    5'-[end of NA]-AGGCGGCCGC-[16 X N]-3'\n",
    "    \n",
    "The end of NA is:\n",
    "\n",
    "    ...CACGATAGATAAATAATAGTGCACCAT\n",
    "    \n",
    "The end of HA is:\n",
    "\n",
    "    ...CCGGATTTGCATATAATGATGCACCAT\n",
    "    \n",
    "The sequencing run reads from the reverse end of the molecules, so the first thing in the sequencing reads is the reverse complement of the barcode followed by the constant sequence and the end of HA or NA."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to determine which reads have valid sequences, get the barcodes out of strings, figure out if the barcode matches to HA or NA, and count the barcodes.\n",
    "So this requires setting up an analysis that does the following:\n",
    "\n",
    " 1. Get the reverse complement of each read.\n",
    " 2. Determine if it matches the expected pattern for HA and NA, and if so which one.\n",
    " 3. If it matches, extract the barcode and add it to a dictionary to keep track of counts.\n",
    " 4. Determine the number and distribution of barcodes for HA and NA separately.\n",
    "\n",
    "### Parsing the barcodes into a dictionary\n",
    "Here we will write and example of how to do most of this but **not** distinguishing among whether the barcode matches HA or NA.\n",
    "For your homework (see end of the notebook) you will have to extend this in class analysis to get statistics separately for HA and NA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parsed 10000 sequences, of which 569 lacked valid barcodes\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "import Bio.SeqIO\n",
    "\n",
    "\n",
    "def reverse_complement(seq):\n",
    "    \"\"\"Get reverse complement of a DNA sequence.\n",
    "    \n",
    "    Parameters\n",
    "    -----------\n",
    "    seq : str\n",
    "        Uppercase DNA sequence.\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    str\n",
    "        Reverse complement of the sequence in upper case.\n",
    "        \n",
    "    Example\n",
    "    --------\n",
    "    >>> reverse_complement('ATGCAC')\n",
    "    'GTGCAT'\n",
    "    \n",
    "    \"\"\"\n",
    "    rc_dict = {'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G', 'N': 'N'}\n",
    "    revcomplement = []\n",
    "    for nt in reversed(seq.upper()):\n",
    "        revcomplement.append(rc_dict[nt])\n",
    "    return ''.join(revcomplement)\n",
    "\n",
    "\n",
    "def read_barcode(seqread, bclen, upstream='AGGCGGCCGC'):\n",
    "    \"\"\"Identify barcode with known upstream sequence.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    seqread : str\n",
    "        Nucleotide sequence matching UPSTREAM-BARCODE read in reverse orientation.\n",
    "    bclen : int\n",
    "        Length of barcode\n",
    "    upstream: str\n",
    "        Sequence upstream of the barcode.\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    str or None\n",
    "        Sequence of the barcode in the forward orientation, or `None` if no match to expected barcoded sequence.\n",
    "        \n",
    "    Example\n",
    "    -------\n",
    "    >>> read_barcode('TTTTTTTTTTTTTTTTGCGGCCGCCT', bclen=16)\n",
    "    'AAAAAAAAAAAAAAAA'\n",
    "        \n",
    "    \"\"\"\n",
    "    barcode_matcher = re.compile(f'^(?P<barcode>[ACGT]{{{bclen}}})' + reverse_complement(upstream))\n",
    "    m = barcode_matcher.search(seqread)\n",
    "    if not m:\n",
    "        return None\n",
    "    else:\n",
    "        return reverse_complement(seqread[: bclen])\n",
    "    \n",
    "    \n",
    "# now read sequences and apply function\n",
    "seqreads = list(Bio.SeqIO.parse('barcodes_R1.fastq', 'fastq'))\n",
    "seqreads_str = [str(seqrecord.seq) for seqrecord in seqreads]\n",
    "\n",
    "# Get the counts of all barcodes\n",
    "barcode_counts = {}\n",
    "n_invalid = 0\n",
    "for seq in seqreads_str:\n",
    "    barcode = read_barcode(seq, bclen=16)\n",
    "    if not barcode:\n",
    "        n_invalid += 1\n",
    "    elif barcode not in barcode_counts:\n",
    "        barcode_counts[barcode] = 1\n",
    "    else:\n",
    "        barcode_counts[barcode] += 1\n",
    "        \n",
    "print(f\"Parsed {len(seqreads_str)} sequences, of which {n_invalid} lacked valid barcodes\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a data frame with the barcode counts\n",
    "We create a [pandas DataFrame](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html) with the barcode counts.\n",
    "These data frames are a great way to represent any information that can ultimately be thought of in tabular form.\n",
    "They are roughly the Python equivalent to the `R` data frames / tables discussed in earlier lectures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>barcode</th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ACTAAATAACTTAAGC</td>\n",
       "      <td>63</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AACCGTGACCAGGAAG</td>\n",
       "      <td>70</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>CCACATTCATCGCTGA</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>TTATCGTCTCCCATAT</td>\n",
       "      <td>78</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CTACCCGTTTCCCAAC</td>\n",
       "      <td>124</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>430</th>\n",
       "      <td>ATTGCATGACTACAAC</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>431</th>\n",
       "      <td>TTACGATCCTCAAGAA</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>432</th>\n",
       "      <td>GCACATAAGGAGCCAA</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>433</th>\n",
       "      <td>AATACGAACATATCGG</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>434</th>\n",
       "      <td>GCTACTACTATACCTT</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>435 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              barcode  count\n",
       "0    ACTAAATAACTTAAGC     63\n",
       "1    AACCGTGACCAGGAAG     70\n",
       "2    CCACATTCATCGCTGA     30\n",
       "3    TTATCGTCTCCCATAT     78\n",
       "4    CTACCCGTTTCCCAAC    124\n",
       "..                ...    ...\n",
       "430  ATTGCATGACTACAAC      1\n",
       "431  TTACGATCCTCAAGAA      1\n",
       "432  GCACATAAGGAGCCAA      1\n",
       "433  AATACGAACATATCGG      1\n",
       "434  GCTACTACTATACCTT      1\n",
       "\n",
       "[435 rows x 2 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas\n",
    "\n",
    "barcode_counts_df = pandas.Series(barcode_counts).reset_index()\n",
    "\n",
    "barcode_counts_df.columns = ['barcode', 'count']\n",
    "\n",
    "barcode_counts_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at a few entries in a data frame: the [head](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.head.html) and [tail](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.tail.html) commands:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>barcode</th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>430</th>\n",
       "      <td>ATTGCATGACTACAAC</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>431</th>\n",
       "      <td>TTACGATCCTCAAGAA</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>432</th>\n",
       "      <td>GCACATAAGGAGCCAA</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>433</th>\n",
       "      <td>AATACGAACATATCGG</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>434</th>\n",
       "      <td>GCTACTACTATACCTT</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              barcode  count\n",
       "430  ATTGCATGACTACAAC      1\n",
       "431  TTACGATCCTCAAGAA      1\n",
       "432  GCACATAAGGAGCCAA      1\n",
       "433  AATACGAACATATCGG      1\n",
       "434  GCTACTACTATACCTT      1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "barcode_counts_df.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sorting a data frame: the [sort_values](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.sort_values.html) command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>barcode</th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>CCCGACCCGACATTAA</td>\n",
       "      <td>158</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>ACCAGTTCTCCCCGGG</td>\n",
       "      <td>154</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>TCAAGAAGCCTTGGAG</td>\n",
       "      <td>152</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>TGACGATCCTCAAGAA</td>\n",
       "      <td>145</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>CGTCTTCCATCCCCAT</td>\n",
       "      <td>136</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>281</th>\n",
       "      <td>ACTAAAGAACTTAAGC</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>282</th>\n",
       "      <td>TGACATAGCGAGACGG</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>283</th>\n",
       "      <td>CGAATCTGCGCAATCC</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>284</th>\n",
       "      <td>TGGGCAATAAACGTAG</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>434</th>\n",
       "      <td>GCTACTACTATACCTT</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>435 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              barcode  count\n",
       "31   CCCGACCCGACATTAA    158\n",
       "49   ACCAGTTCTCCCCGGG    154\n",
       "27   TCAAGAAGCCTTGGAG    152\n",
       "48   TGACGATCCTCAAGAA    145\n",
       "8    CGTCTTCCATCCCCAT    136\n",
       "..                ...    ...\n",
       "281  ACTAAAGAACTTAAGC      1\n",
       "282  TGACATAGCGAGACGG      1\n",
       "283  CGAATCTGCGCAATCC      1\n",
       "284  TGGGCAATAAACGTAG      1\n",
       "434  GCTACTACTATACCTT      1\n",
       "\n",
       "[435 rows x 2 columns]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "barcode_counts_df.sort_values('count', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# use pandas built in plotting\n",
    "\n",
    "fig = barcode_counts_df.plot.hist('count')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting the data frame\n",
    "Python has lots of ways to make plots:\n",
    "\n",
    " - [matplotlib](https://matplotlib.org/): The base Python plotting library, you can do almost anything with it.\n",
    " - [seaborn](https://seaborn.pydata.org/): Useful to easily make certain kinds of complex scientific plots.\n",
    " - [Altair](https://altair-viz.github.io/): Developed at University of Washington, great for making **interactive** plots.\n",
    " - [plotting directly from pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html): Useful if you have a data frame and need a quick and simple plot.\n",
    " \n",
    "We aren't going to use any of those--instead we are going to use [plotnine](https://plotnine.readthedocs.io/).\n",
    "This isn't the most commonly used Python plotting library, but it's what I use.\n",
    "[plotnine](https://plotnine.readthedocs.io/) is essentially a `ggplot2`-mimic for Python.\n",
    "Note that isn't quite as good as the real `ggplot2` for `R` (for instance, it can't do some of the more complex things that `ggplot2` can do), but it can do all the major basic `ggplot2` things.\n",
    "The reason I use it is:\n",
    "\n",
    " 1. I don't think Python has any plotting library as good as `ggplot2` for `R` (unless perhaps you are talking about making interactive plots with [Altair](https://altair-viz.github.io/)), and I prefer the `ggplot2`.\n",
    " \n",
    " 2. I sometimes use `R` as well as Python, and since `plotnine` syntax is almost identical to `ggplot2` syntax, it means that I only have to remember one set of plotting commands and so it is easier to move back and forth. This is the main reason we'll use it in this class too--it will allow us to build on the knowledge you learned about `ggplot2` earlier in the course.\n",
    " \n",
    "First, we import `plotnine`.\n",
    "In order to get the commands in the same way as in `R`, we have to do the `from plotnine import *` command below to get all of the commands from `plotnine` in the current namespace.\n",
    "Note that this type of import is generally considered **bad** Python coding (see [here](https://stackoverflow.com/questions/2386714/why-is-import-bad))--one of the nice things about Python compared to `R` is normally there are clear namespaces that tell you what module a function belongs to.\n",
    "But the `import *` is OK for `plotnine` in Jupyter notebooks (don't do it in more complex code) as it allows the `ggplot2`-like plotting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from plotnine import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can plot the data frame very easily using `ggplot2`-like syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jbloom/.local/lib/python3.6/site-packages/plotnine-0.6.0-py3.6.egg/plotnine/stats/stat_bin.py:93: PlotnineWarning: 'stat_bin()' using 'bins = 19'. Pick better value with 'binwidth'.\n",
      "  warn(msg.format(params['bins']), PlotnineWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<ggplot: (307798448)>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = (ggplot(barcode_counts_df) +\n",
    "     aes('count') +\n",
    "     geom_histogram()\n",
    "     )\n",
    "\n",
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Faceting the plot\n",
    "What if we had barcode counts for several **different** categories (such as genes)?\n",
    "In an earlier lecture, Rasi told you about the power of `facet_wrap` in `ggplot2`.\n",
    "We can use that in `plotnine` as well.\n",
    "\n",
    "Here we do this on made up data, where we simply imaging that our same data multiplied by two is a second category.\n",
    "\n",
    "First, we now make a merged data frame with the original data and the data multiplied by two.\n",
    "Note how we do this using the [pandas.concat](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.concat.html) function, and how we use [assign](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.assign.html) to name the data in each data frame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>barcode</th>\n",
       "      <th>count</th>\n",
       "      <th>dummy_variable</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ACTAAATAACTTAAGC</td>\n",
       "      <td>63</td>\n",
       "      <td>category_1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AACCGTGACCAGGAAG</td>\n",
       "      <td>70</td>\n",
       "      <td>category_1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>CCACATTCATCGCTGA</td>\n",
       "      <td>30</td>\n",
       "      <td>category_1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>TTATCGTCTCCCATAT</td>\n",
       "      <td>78</td>\n",
       "      <td>category_1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CTACCCGTTTCCCAAC</td>\n",
       "      <td>124</td>\n",
       "      <td>category_1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>638</th>\n",
       "      <td>GCGGCAGAGCTGCTTT</td>\n",
       "      <td>6</td>\n",
       "      <td>category_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>639</th>\n",
       "      <td>GACTTACGGCGTCATG</td>\n",
       "      <td>2</td>\n",
       "      <td>category_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>640</th>\n",
       "      <td>CATACCTTTCTGACTT</td>\n",
       "      <td>3</td>\n",
       "      <td>category_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>641</th>\n",
       "      <td>AGGGGCACGAGTCGCC</td>\n",
       "      <td>2</td>\n",
       "      <td>category_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>642</th>\n",
       "      <td>ACAGGCAGCTACGGGA</td>\n",
       "      <td>3</td>\n",
       "      <td>category_2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>643 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              barcode  count dummy_variable\n",
       "0    ACTAAATAACTTAAGC     63     category_1\n",
       "1    AACCGTGACCAGGAAG     70     category_1\n",
       "2    CCACATTCATCGCTGA     30     category_1\n",
       "3    TTATCGTCTCCCATAT     78     category_1\n",
       "4    CTACCCGTTTCCCAAC    124     category_1\n",
       "..                ...    ...            ...\n",
       "638  GCGGCAGAGCTGCTTT      6     category_2\n",
       "639  GACTTACGGCGTCATG      2     category_2\n",
       "640  CATACCTTTCTGACTT      3     category_2\n",
       "641  AGGGGCACGAGTCGCC      2     category_2\n",
       "642  ACAGGCAGCTACGGGA      3     category_2\n",
       "\n",
       "[643 rows x 3 columns]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dummy_df = (\n",
    "    barcode_counts_df.assign(dummy_variable='category_1')\n",
    "    .append(barcode_counts_df.query('count > 1').assign(dummy_variable='category_2'))\n",
    "    .reset_index(drop=True)\n",
    "    )\n",
    "\n",
    "dummy_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now plot the data using `facet_wrap`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jbloom/.local/lib/python3.6/site-packages/plotnine-0.6.0-py3.6.egg/plotnine/stats/stat_bin.py:93: PlotnineWarning: 'stat_bin()' using 'bins = 15'. Pick better value with 'binwidth'.\n",
      "  warn(msg.format(params['bins']), PlotnineWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<ggplot: (-9223372036546523325)>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = (ggplot(dummy_df) +\n",
    "     aes('count') +\n",
    "     geom_histogram() +\n",
    "     facet_wrap('~ dummy_variable')\n",
    "     )\n",
    "\n",
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework assignment\n",
    "For the homework, you are going to extend the code above to completely analyze the [real biological analysis of our FASTQ files](#real_analysis).\n",
    "As described in that section, the FASTQ reads can originate from **either** HA or NA, and that will be distinguished by the most 3' end of the read.\n",
    "But in our example, we did not distinguish among reads matching to HA and NA, as we didn't even look far enough into the read to tell the identity.\n",
    "\n",
    "For the homework, your goal is to write code that extends the parsing above to also distinguish between HA and NA, and then eventually get those results into a single data frame from which you can plot a histogram of read counts using `facet_wrap`.\n",
    "This homework can be completed almost entirely be re-using code above.\n",
    "\n",
    "You can complete the homework by just writing the analysis at the bottom of this Jupyter notebook (below this cell).\n",
    "Your analysis should explicitly contain answers to the following:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {
    "height": "623.8px",
    "left": "0px",
    "right": "829.6px",
    "top": "33.2px",
    "width": "322.4px"
   },
   "toc_section_display": "block",
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}