BF527_Lab_06_Nested_PairwiseSeqComparison.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lab 6\n",
    "### Nested Lists, Nested Loops, and Pairwise Sequence Comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Today we will learn about nesting methods, such as lists within lists or loops within loops.\n",
    "We’ve already encountered <font color='red'>if</font>-statements within <font color='red'>for</font>-loops, but today we’ll do multiple nested loops to demonstrate pairwise sequence comparison, e.g. as we would do it in global sequence alignment.\n",
    "\n",
    "You will follow along in a Jupyter notebook, and run the code as we go through it together.\n",
    "Feel free to try to play around as we progress to get a better feel for how things work.\n",
    "\n",
    "#### REMEMBER, THE INTERNET IS YOUR FRIEND: [Python.org Tutorials](http://docs.python.org/tutorial/)\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Part A: A review of lists\n",
    "\n",
    "List is a sequential object with multiple individual elements that can be strings, numbers, or even other lists. We can easily _*nest*_ one list within another list, and therefore create a matrix or a table. First, let’s refresh our memories about lists and the elements they can store. Check out the code chunk below. Once you've read it, run the chunk, and see whether the output chunk jives with your understanding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1, 2.4, 'Dmitriy', 5, 'David']\n",
      "[[1, 2, 3, 4, 5], [1, 2.4, 'Dmitriy', 5, 'David']]\n"
     ]
    }
   ],
   "source": [
    "#First things first:\n",
    "#to run the code press ctrl-enter\n",
    "#the code below is in Python 2.7.  What would you do to change it to 3.x?\n",
    "\n",
    "#lists are good for storing more than one piece of data\n",
    "number_list = [1, 2, 3, 4, 5]\n",
    "print(number_list)\n",
    "\n",
    "#lists are good for storing different data types\n",
    "misc_list = [1, 2.4, 'Dmitriy', 5, 'David']\n",
    "print(misc_list)\n",
    "\n",
    "#lists can also store other lists - this is called nesting\n",
    "#this is a list of the two previous lists!\n",
    "list_of_lists = [[1, 2, 3, 4, 5], [1, 2.4, 'Dmitriy', 5,'David']]\n",
    "print(list_of_lists)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check out `list_of_lists` -- it's exactly what the variable name says! \n",
    "\n",
    "As a reminder, Python _indexes by 0_. So, The first element, `list_of_lists[0]`, is actually `number_list`, and `list_of_lists[1]` is the same as `misc_list`\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Part B: Nested Lists\n",
    "1 | 2 | 3\n",
    "--- | --- | ---\n",
    "4 | 5 | 6\n",
    "7 | 8 | 9\n",
    "10 | 11 | 12\n",
    "13 | 14 | 15\n",
    "\n",
    "We’ve learned that we can nest one list inside another list. This means that we can use\n",
    "nested lists to create, for example, a matrix or a table of numbers (see above).\n",
    "We’ve also learned how to access the individual elements of nested lists, by first accessing\n",
    "the list itself using its index, and then accessing the element using another level of indexing.\n",
    "Let’s try to represent the above matrix of numbers in Python, as a list of lists!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "full matrix: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]\n",
      "number of rows: 5\n",
      "number of columns: 3\n"
     ]
    }
   ],
   "source": [
    "#Matrix of numbers: 5 rows by 3 columns\n",
    "#rows = nested lists (5 nested lists)\n",
    "#columns = elements within a list (3 elements per row)\n",
    "matrix = [[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15]]\n",
    "\n",
    "print ('full matrix:', matrix)\n",
    "#total number of rows (length of full matrix)\n",
    "print ('number of rows:', len(matrix))\n",
    "#total number of columns (length of the first row)\n",
    "print ('number of columns:', len(matrix[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we want to access individual elements in the matrix?\n",
    "First, identify the row, then identify the column.\n",
    "*E.g.* the number 11 is in row 4, column 2 (remember, Python is *zero-indexed!*). So, the actual code to access this number would be `matrix[3][1]`\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Part C: Nested Loops\n",
    "Now that we’ve learned how to make nested lists and access individual elements of nested\n",
    "lists, let’s try sequentially accessing elements in nested lists, _without knowing their indexes\n",
    "ahead of time_. We can go through every column of every row by having a loop within a loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row column element\n",
      "0\t0\t1\n",
      "0\t1\t2\n",
      "0\t2\t3\n",
      "1\t0\t4\n",
      "1\t1\t5\n",
      "1\t2\t6\n",
      "2\t0\t7\n",
      "2\t1\t8\n",
      "2\t2\t9\n",
      "3\t0\t10\n",
      "3\t1\t11\n",
      "3\t2\t12\n",
      "4\t0\t13\n",
      "4\t1\t14\n",
      "4\t2\t15\n"
     ]
    }
   ],
   "source": [
    "#let's get the (row, column) index for every element in our matrix\n",
    "#the first loop goes through each row\n",
    "#the second loop goes through each column WITHIN THAT ROW\n",
    "#r = row, c = column, i = item at position (r,c)\n",
    "print ('row column element')\n",
    "\n",
    "# two typ0s were introduced in the code below\n",
    "#for row i in the matrix\n",
    "for i in range(len(matrix)):\n",
    "    #for column j in row i\n",
    "    for j in range(len(matrix[i])):\n",
    "        print (i, j, matrix[i][j], sep = \"\\t\")\n",
    "\n",
    "#what does the code chunk 'sep = \"\\t\"' do?\n",
    "               \n",
    "# Hint: to add line numbers, type ctrl-m, then l # new version: shift + L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This script is only four lines of code, but it does a very complex operation; this is the beauty\n",
    "of programming. Make sure you understand how it works!\n",
    "\n",
    "Hint: imagine covering up the table and looking only at the 1st row (row 0), then looking only\n",
    "at the 1st item (item 0): the item in (0,0) is 1. Similarly, the item in (4,0) is 13: 5th row, 1st\n",
    "item. Remember, Python starts its counting at 0, so all indexes will seem off by one!\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Part D: Comparing sequences using nested loops\n",
    "Now we know how to make nested lists, and how to make nested loops. Now we have all the\n",
    "necessary components to do pairwise sequence alignment. Remember, in Python, strings are\n",
    "sequential objects, meaning that they contain multiple elements organized in a specific order\n",
    "– _just like lists_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i x[i]  j y[j] match?\n",
      "0   G   0   G   YES\n",
      "0   G   1   A   NO\n",
      "0   G   2   T   NO\n",
      "0   G   3   A   NO\n",
      "0   G   4   G   YES\n",
      "0   G   5   A   NO\n",
      "1   A   0   G   NO\n",
      "1   A   1   A   YES\n",
      "1   A   2   T   NO\n",
      "1   A   3   A   YES\n",
      "1   A   4   G   NO\n",
      "1   A   5   A   YES\n",
      "2   T   0   G   NO\n",
      "2   T   1   A   NO\n",
      "2   T   2   T   YES\n",
      "2   T   3   A   NO\n",
      "2   T   4   G   NO\n",
      "2   T   5   A   NO\n",
      "3   T   0   G   NO\n",
      "3   T   1   A   NO\n",
      "3   T   2   T   YES\n",
      "3   T   3   A   NO\n",
      "3   T   4   G   NO\n",
      "3   T   5   A   NO\n",
      "4   A   0   G   NO\n",
      "4   A   1   A   YES\n",
      "4   A   2   T   NO\n",
      "4   A   3   A   YES\n",
      "4   A   4   G   NO\n",
      "4   A   5   A   YES\n",
      "5   C   0   G   NO\n",
      "5   C   1   A   NO\n",
      "5   C   2   T   NO\n",
      "5   C   3   A   NO\n",
      "5   C   4   G   NO\n",
      "5   C   5   A   NO\n",
      "6   A   0   G   NO\n",
      "6   A   1   A   YES\n",
      "6   A   2   T   NO\n",
      "6   A   3   A   YES\n",
      "6   A   4   G   NO\n",
      "6   A   5   A   YES\n"
     ]
    }
   ],
   "source": [
    "#Let's compare the sequence GATTACA to GATAGA\n",
    "x = 'GATTACA'\n",
    "y = 'GATAGA'\n",
    "\n",
    "#Previously, our nested loops accessed the same variable (matrix)\n",
    "#We can set up our loops so that the outer loop accesses one variable,\n",
    "#and the inner loop accesses another.\n",
    "\n",
    "#i = position in sequence x; x[i] is the letter at the ith position of x\n",
    "#j = position in sequence y; y[j] is the letter at the jth position of y\n",
    "print ('i x[i]  j y[j] match?')\n",
    "\n",
    "#For every letter of x...\n",
    "# you'll need to correct the code to match Python3.6 syntax\n",
    "for i in range(len(x)):\n",
    "        #For every letter of y...\n",
    "        for j in range(len(y)):\n",
    "            #Compare each letter\n",
    "            #If there's a match...\n",
    "            if x[i] == y[j]:\n",
    "                print(i, x[i], j, y[j], 'YES', sep =\"   \")\n",
    "            #If there's a mismatch...\n",
    "            else:\n",
    "                print(i, x[i], j, y[j], 'NO', sep =\"   \")\n",
    "                \n",
    "#what does the code chunk 'sep = \"   \"' do? # separator between the arguments in print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, this is only three lines of code, but it’s very complicated! The first `for` loop goes\n",
    "through every letter of `X`. Then the second `for` loop goes through every letter of `Y`. So for\n",
    "every _letter_ of `X`, the computer checks all of `Y = GATAGA`, _every time_! This is why you see\n",
    "`GATAGA` printed multiple times. This is very tedious and not the way that humans would do it,\n",
    "but it works for computers.\n",
    "\n",
    "Hint: imagine looking at `X = GATTACA`, and looking at the first letter: `X1=G`. Then look at `Y =\n",
    "GATAGA`, again only the letter: `Y1=G`. Then look at the second letter (`Y2 = A`), the third letter\n",
    "(`Y3 = T`), etc. Once you’ve finished with Y, then look at the second letter of X: `X2 = A`! Then\n",
    "look through Y1, Y2, Y3 again… and so on, and so on…\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Part E: appending to lists and incrementing counters\n",
    "So far, we have initialized lists with existing elements, but we can also initialize an empty\n",
    "list, and add to the list later. This is similar to the idea of incrementing a counter. In Lab 03,\n",
    "we learned advanced list manipulation, and learned how to add items to a list using the\n",
    "`append()` function.\n",
    "\n",
    "Tip: `str()` will change the object (such as an integer) into a string; `+` will concatenate\n",
    "two strings together into one string. This is a new way to print strings and integers on a line\n",
    "together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequence: CAGTCAGTAAACCTGG\n",
      "purine (index):\n",
      "A(2)\n",
      "G(3)\n",
      "A(6)\n",
      "G(7)\n",
      "A(9)\n",
      "A(10)\n",
      "A(11)\n",
      "G(15)\n",
      "G(16)\n",
      "Total number of purines: 9\n",
      "List of purines found, in order: ['A', 'G', 'A', 'G', 'A', 'A', 'A', 'G', 'G']\n"
     ]
    }
   ],
   "source": [
    "#Let's count the purines (A, G) in the following sequence\n",
    "#We'll use range(len()) to identify the index of the purine\n",
    "#We'll use a counter t ocount the total number of purines\n",
    "#and we'll use an empty list to save the purines in a new variable\n",
    "sequence = 'CAGTCAGTAAACCTGG'\n",
    "num_purines = 0    #counter\n",
    "purines = []       #new EMPTY list for the purines\n",
    "\n",
    "print ('Sequence:', sequence)\n",
    "print ('purine (index):')\n",
    "\n",
    "#Loop through each letter of the sequence:\n",
    "for i in range(len(sequence)):\n",
    "    #Use a variable to store the current nucleotide:\n",
    "    nucleotide = sequence[i]\n",
    "    #Check if the nucleotide is a purine\n",
    "    if nucleotide in ['A', 'G']:\n",
    "        num_purines = num_purines + 1  #We found a new purine!\n",
    "        purines.append(nucleotide)     #Save that specific base\n",
    "        #Print out the position in the sequence\n",
    "        print(nucleotide + '(' + str(i + 1) + ')')\n",
    "        \n",
    "print ('Total number of purines:', num_purines)\n",
    "print ('List of purines found, in order:', purines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Lab Task\n",
    "For today’s lab task, we’ll use nested loops and lists to create a new number\n",
    "matrix. We’ll use the `range()` function in a unique way, by making use of its step argument,\n",
    "which allows it to increment on a number other than 1. First, let’s read through Python’s\n",
    "documentation on `range()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "Function 'range(stop)': \n",
      "0 1 2 3 4 \n",
      "Function 'range(start, stop)':\n",
      "2 3 4 \n",
      "Function 'range(start, stop, step)': \n",
      "2 5 8 \n",
      "Function 'range(start, stop, step)': \n",
      "2 \n",
      "Function 'range(start, stop, step)': \n",
      "2 12 \n",
      "\n",
      "\n",
      "Help on class range in module builtins:\n",
      "\n",
      "class range(object)\n",
      " |  range(stop) -> range object\n",
      " |  range(start, stop[, step]) -> range object\n",
      " |  \n",
      " |  Return an object that produces a sequence of integers from start (inclusive)\n",
      " |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
      " |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
      " |  These are exactly the valid indices for a list of 4 elements.\n",
      " |  When step is given, it specifies the increment (or decrement).\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      True if self else False\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\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",
      " |  __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",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(...)\n",
      " |      Return a reverse iterator.\n",
      " |  \n",
      " |  count(...)\n",
      " |      rangeobject.count(value) -> integer -- return number of occurrences of value\n",
      " |  \n",
      " |  index(...)\n",
      " |      rangeobject.index(value) -> integer -- return index of value.\n",
      " |      Raise ValueError if the value is not present.\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",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  start\n",
      " |  \n",
      " |  step\n",
      " |  \n",
      " |  stop\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Remember, you can always learn how a function works by passing\n",
    "#its name to the help() function\n",
    "#help(range)\n",
    "\n",
    "#...or by playing with examples:\n",
    "m = [1,2,3]\n",
    "print(m)\n",
    "\n",
    "print (\"Function 'range(stop)': \")\n",
    "for i in range(5):\n",
    "    print (i, end =\" \")\n",
    "print()\n",
    "\n",
    "print (\"Function 'range(start, stop)':\")\n",
    "for i in range(2,5):\n",
    "    print (i, end =\" \")\n",
    "print()\n",
    "\n",
    "print (\"Function 'range(start, stop, step)': \")\n",
    "for i in range(2,10,3):\n",
    "    print (i, end =\" \")\n",
    "print()\n",
    "\n",
    "print (\"Function 'range(start, stop, step)': \")\n",
    "for i in range(2,3,10):\n",
    "    print (i, end =\" \")\n",
    "print()\n",
    "\n",
    "print (\"Function 'range(start, stop, step)': \")\n",
    "for i in range(2,20,10):\n",
    "    print (i, end =\" \")\n",
    "print(\"\\n\\n\")\n",
    "\n",
    "help(range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your goal for today is to use range and append function of lists to make the following number matrix:\n",
    "\n",
    "1 | 2 | 3 | 4 | 5\n",
    "--- | --- | --- | --- | ---\n",
    "6 | 7 | 8 | 9 | 10\n",
    "11 | 12 | 13 | 14 | 15\n",
    "\n",
    "**OBJECTIVES:**\n",
    "\n",
    "In the Python cell below:\n",
    "1. Create an empty list where you will subsequently store your matrix.\n",
    "2. Use `range()` to generate a list of numbers that begin each row of the matrix. Save the result in a variable called `begin_numbers`; you will use it later to generate the row of your table. Remeber that Python adds `+1` when counting, so make sure `stop` is correct. (*Hint:* your list should be: [1, 6, 11]. What are the values of `start`, `stop`, and `step` that you need to enter in order to get such a list?\n",
    "3. Use a `for` loop to go through `begin_numbers`. As you go through the loop, use `range()` again to generate that row of the table. For example, the first element in `begin_numbers[1]` can be used to generate the first row of the table (`[1, 2, 3, 4, 5]`). Once you've generated the row, save it in the matrix using the `append()` function. (This needs to be done in the `for` loop!)\n",
    "4. Finally, print your completed matrix.\n",
    "5. When your code is working properly, save a copy of this .ipynb file in the format \"Lab5\" + your name, and submit it on Blackboard for credit.\n",
    "6. *Don't forget to write comments!*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[6, 7, 8, 9, 10]\n",
      "[11, 12, 13, 14, 15]\n"
     ]
    }
   ],
   "source": [
    "#write your python code here\n",
    "# to add line numbers, type ctrl-m, then l\n",
    "\n",
    "#create an empty list to store matrix\n",
    "my_matrix =[]\n",
    "\n",
    "#creat a list to store begin numbers\n",
    "begin_numbers =[]\n",
    "\n",
    "#generate a list for begin numbers\n",
    "for i in range(1,12,5):\n",
    "    begin_numbers.append(i)\n",
    "#check the first result\n",
    "#print(begin_numbers) \n",
    "\n",
    "#construct each row for my matrix \n",
    "#initiate an empty row list\n",
    "row_list=[]\n",
    "\n",
    "#every row list begins with a begin number j\n",
    "for j in begin_numbers:\n",
    "#then increase to j+5\n",
    "#step is 1\n",
    "    for n in range(j,j+5):\n",
    "        row_list.append(n)\n",
    "    # add row list to final matrix\n",
    "    my_matrix.append(row_list)\n",
    "    # starts for next row with an empty initial list\n",
    "    row_list=[]\n",
    "    \n",
    "for row in my_matrix:\n",
    "    print(row, sep =\"\\t\")# seperate the matrix by "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}