Lesson_2_Control_Structs/Lesson_2_Control_structs_teacher.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/How-to-Learn-to-Code/python-class/blob/master/Lesson_2_Control_Structs/Lesson_2_Control_structs_teacher.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "T5WJjJnfpZWM"
   },
   "source": [
    "# Lesson 2 - Data structures, Control flows, and Python Ecosystems\n",
    "\n",
    "### Learning objectives: \n",
    "\n",
    "Students will be able to use data structures and control flows to make algorithms.\n",
    "\n",
    "### Specific coding skills:\n",
    "\n",
    "* Understanding basic data structures (list, dictionary, tuple, set)\n",
    "* Using if/else statements\n",
    "* Using loops (while/for)\n",
    "* Understanding python ecosystem and how packages work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L7kujO9M3V0X"
   },
   "source": [
    "## Introduction\n",
    "\n",
    "Data structures are basically just that - they are structures which can hold some data together. In other words, they are used to store a collection of related data. These are particularly helpful when working with experimental data sets. There are four built-in data structures in Python - list, tuple, dictionary and set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2mcXMmme9jbI"
   },
   "source": [
    "## Data structures\n",
    "\n",
    "There are four built-in data structures in python: lists,tuples, sets, and dictionary. In this lesson, we will learn about each data structures.\n",
    "\n",
    "### Lists\n",
    "\n",
    "A `list` is a data structure that holds an ordered collection of items i.e. you can store a sequence of items in a list. This is easy to imagine if you can think of a shopping list where you have a list of items to buy, except that you probably have each item on a separate line in your shopping list whereas in Python you put commas in between them.\n",
    "\n",
    "Here are important properties of lists:\n",
    "\n",
    "* Lists are ordered – Lists remember the order of items inserted.\n",
    "* Accessed by index – Items in a list can be accessed using an index.\n",
    "* Lists can contain any sort of object – It can be numbers, strings, tuples and even other lists.\n",
    "* Lists are changeable (mutable) – You can change a list in-place, add new items, and delete or update existing items.\n",
    "\n",
    "Let's create a list containing five different genes. In Python, a list is created by placing elements inside square brackets `[]`, separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jlcZE-UfpPmZ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['EGFR', 'KRAS', 'MYC', 'RB', 'TP53']\n"
     ]
    }
   ],
   "source": [
    "gene_list = ['EGFR', 'KRAS', 'MYC', 'RB', 'TP53']\n",
    "print(gene_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List operations\n",
    "Now let's learn what we can do with lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Accessing list elements: indexing/slicing\n",
    "\n",
    "We can access list items using index opreator. In python, indices start at 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![indexing](https://cdn.programiz.com/sites/tutorial2program/files/python-list-index.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try to access the second gene in our `gene_list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'KRAS'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene_list[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also has 'negative indices' which can be very convinient when we want to access last i-th item. Last item in the list can be accessed with index of -1. Let's try to access the second to last item in `gene_list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'RB'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene_list[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also access a *range* of items in al list using the slicing operator `:`. Let's try to access the first three items in `gene_list`. Note that the start index is *inclusive*, but end index is *exclusive*. We will see later when this can be useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['EGFR', 'KRAS', 'MYC']\n",
      "['EGFR', 'KRAS', 'MYC']\n"
     ]
    }
   ],
   "source": [
    "# first three items\n",
    "print(gene_list[0:3])\n",
    "# beginning index (0) can be ommitteed\n",
    "print(gene_list[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What should we do if we want to access the last three items?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# last three items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are interested in a new cancer gene, PTEN, and want to add this to our gene list. How should we do this? There are a few ways to do this, and one way is using a list method called, *append*. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['EGFR', 'KRAS', 'MYC', 'RB', 'TP53', 'PTEN']"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene_list.append('PTEN')\n",
    "gene_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oop, we were supposed add BRAF instead of PTEN! What should we do? Since lists are *mutable*, we can repalce PTEN with BRAF."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PTEN'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene_list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['EGFR', 'KRAS', 'MYC', 'RB', 'TP53', 'BRAF']"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene_list[-1] = 'BRAF'\n",
    "gene_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are other useful list methods that we can use to alterate and describe lists.\n",
    "\n",
    "#### Some useful functions and list methods\n",
    "\n",
    "- list.**append(x)**: Add an item *x* to the end of the list.\n",
    "- list.**remove(x)**: Remove the first item from the list whose value is equal to *x*. \n",
    "- list.**count(x)**: Return the number of times *x* appears in the list.\n",
    "\n",
    "- **reversed(l)**: Reverse the order of items in list *l* and return the new list.\n",
    "- **sorted(l)**: Sort the order of values in list *l* (default is in ascending order) and return the new list.\n",
    "- **len(l)**: Return the length of list *l*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Tuples are ordered collection of values. Tuples are similar to lists with one major difference. They are are *immutable*, meaning that we cannot change, add, or remove items after they are created. We an create a tuple by placing comma-seperated values inside `()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "gene_tuple = ('EGFR', 'KRAS', 'MYC', 'RB', 'TP53')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly to lists, we can use indexing and slicing to access items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MYC\n",
      "('RB', 'TP53')\n"
     ]
    }
   ],
   "source": [
    "print(gene_tuple[2])  # access third item\n",
    "print(gene_tuple[-2:])  # access last two items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can we replace KRAS with NRAS for tuples?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' 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-64-d296efa189c8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mgene_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'NRAS'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "gene_tuple[1] = 'NRAS'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This raises error because tuples are *immutable*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "\n",
    "Python set is an unordered collection of unique items. They are commonly used for computing mathematical operations such as union, intersection, difference, and symmetric difference.\n",
    "\n",
    "\n",
    "![set operations](https://www.learnbyexample.org/wp-content/uploads/python/Python-Set-Operatioons.png)\n",
    "\n",
    "\n",
    "The important properties of Python sets are as follows:\n",
    "\n",
    "- Sets are unordered – Items stored in a set aren’t kept in any particular order.\n",
    "- Set items are unique – Duplicate items are not allowed.\n",
    "- Sets are unindexed – You cannot access set items by referring to an index.\n",
    "- Sets are changeable (mutable) – They can be changed in place, can grow and shrink on demand.\n",
    "\n",
    "Sets can be created by placing items comma-seperated values inside `{}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have upregulated genes in tumor tissues compared to normal tissues from two patients. We would like to know if there is a shared upregulated genes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "patient1 = {'ABCC1', 'BRCA1', 'BRCA2', 'HER2'}\n",
    "patient2 = {'BRCA1', 'HER2', 'ERCC1'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'BRCA1', 'HER2'}\n",
      "{'BRCA1', 'HER2'}\n"
     ]
    }
   ],
   "source": [
    "# set intersection\n",
    "print(patient1.intersection(patient2))  # use intersection method\n",
    "print(patient1 & patient2)  # use & operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sbLhhtDPBw_M"
   },
   "source": [
    "### Dictionaries\n",
    "\n",
    "A dictionary is like an address-book where you can find the address or contact details of a person by knowing only his/her name i.e. we associate keys (name) with values (details). Note that the key must be unique just like you cannot find out the correct information if you have two persons with the exact same name.\n",
    "\n",
    "Note that you can use only immutable objects (like strings) for the keys of a dictionary but you can use either immutable or mutable objects for the values of the dictionary.\n",
    "\n",
    "Pairs of keys and values are specified in a dictionary by using the notation `d = {key1 : value1, key2 : value2 }`. Notice that the key-value pairs are separated by a colon and the pairs are separated themselves by commas and all this is enclosed in a pair of curly braces.\n",
    "\n",
    "The following example of a dictionary might be useful if you wanted to keep track of ages of patients in a clinical trial. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PL68GxZAFKit"
   },
   "outputs": [],
   "source": [
    "agesDict = {'Karen P.' : 53, 'Jessica M.': 47, 'David G.' : 45, 'Susan K.' : 57, 'Eric O.' : 50}\n",
    "print(agesDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access a person's age (value) using his/her name (key). Let's find out Eric O.'s age."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agesDict['Eric O.']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A new patient is enrolled into the clinical trial. Her name is Hannah H. and her age is 39. We can add a new item to the dictoary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "agesDict['Hannah H.'] = 39"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Karen P.': 53, 'Jessica M.': 47, 'David G.': 45, 'Susan K.': 57, 'Eric O.': 50, 'Hannah H.': 39}\n"
     ]
    }
   ],
   "source": [
    "print(agesDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Structures Summary\n",
    "\n",
    "Now we have learned the four basic python data structures: list, tuple, set, and dictionary. We have jsut touched the surface of these data structures. To learn more about these data structures and how to use them, please refer to the references!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hOggiwzmMm1Z"
   },
   "source": [
    "### Exercises Part 1\n",
    "\n",
    "The following exercises will help you better understand data structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Make a list containing the following numbers 1, 4, 25, 7, 9, 12, 15, 16, and 21. Name the list `num_list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q1\n",
    "num_list = [1, 4, 25, 7, 9, 12, 15, 16, 21]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Find the following information about the list you made in Q1: length, minimum, and maximum. You may need to google to find functions that can help you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Q2\n",
    "# length\n",
    "len(num_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# minimum\n",
    "min(num_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# maximum\n",
    "max(num_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Make a dictionary that describes the price of five medications. Name the dictionary `med_dict`\n",
    ">* Lisinopril: \t23.07\n",
    ">* Gabapentin: 86.27\n",
    ">* Sildenafil: \t169.94 \n",
    ">* Amoxicillin: 17.76\n",
    ">* Prednisone: 13.81"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q4\n",
    "med_dict = {'Lisinopril': 23.07, 'Gabapentin': 86.27, 'Sildenafil': 169.94, 'Amoxicillin': 17.76, 'Prednisone': 13.81}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Use `med_dict` to calculate how much it will cost if a patien tis treated with Lisinopril and Prednisone."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36.88"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Q5\n",
    "med_dict['Lisinopril'] + med_dict['Prednisone']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jj1BdK9TiThp"
   },
   "source": [
    "## Control flows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If...else statment\n",
    "\n",
    "Decision making is required when we want to execute a code only if a certain condition is satisfied.\n",
    "\n",
    "The `if…elif…else` statement is used in Python for decision making. We can use these statments to execute a block of code only when the condition is true. The `if…elif…else` statement follows this syntax. Note, `elif` is abbreviation for else if.\n",
    "\n",
    "```python\n",
    "if condition1:\n",
    "    statment1\n",
    "elif condition2:\n",
    "    statement2\n",
    "else:\n",
    "    statement3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![ifelse syntax](https://www.learnbyexample.org/wp-content/uploads/python/Python-elif-Statement-Syntax.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's think of a dose-finding clinical trial. We first treat three patients with dose x. iIf no patients shows toxic side effects, we increase the dose. If one patient shows toxicity, we treat another three patients to learn more. If more than one patients show toxicity, we stop at that dose. Let's make this into python code. You can change the value of `n_toxic` to see how the script works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stop\n"
     ]
    }
   ],
   "source": [
    "n_toxic = 2\n",
    "if n_toxic == 0:\n",
    "    print(\"increase dose\")\n",
    "elif n_toxic == 1:\n",
    "    print(\"treat another three patients\")\n",
    "else:\n",
    "    print(\"stop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops\n",
    "\n",
    "There are two types of loops in python: `while` loops and `for` loops. Loops are useful when we want to performe the same task repetitively.\n",
    "\n",
    "#### While loop\n",
    "\n",
    "A while loop is used when you want to perform a task indefinitely, until a particular condition is met.  For instance, we want to enroll new patients to a clinical trial until we have 30 patients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enrolled patient 1\n",
      "enrolled patient 2\n",
      "enrolled patient 3\n",
      "enrolled patient 4\n",
      "enrolled patient 5\n",
      "enrolled patient 6\n",
      "enrolled patient 7\n",
      "enrolled patient 8\n",
      "enrolled patient 9\n",
      "enrolled patient 10\n",
      "enrolled patient 11\n",
      "enrolled patient 12\n",
      "enrolled patient 13\n",
      "enrolled patient 14\n",
      "enrolled patient 15\n",
      "enrolled patient 16\n",
      "enrolled patient 17\n",
      "enrolled patient 18\n",
      "enrolled patient 19\n",
      "enrolled patient 20\n",
      "enrolled patient 21\n",
      "enrolled patient 22\n",
      "enrolled patient 23\n",
      "enrolled patient 24\n",
      "enrolled patient 25\n",
      "enrolled patient 26\n",
      "enrolled patient 27\n",
      "enrolled patient 28\n",
      "enrolled patient 29\n",
      "enrolled patient 30\n"
     ]
    }
   ],
   "source": [
    "n_patients = 1\n",
    "while n_patients <= 30:\n",
    "    print(\"enrolled patient\", n_patients)\n",
    "    n_patients += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do you think will hapen if we use `while True`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### for loop\n",
    "\n",
    "For loops are used for iterating over a sequence of objects i.e. go through each item in a sequence. Iterable of items include lists, tuples, dictonaries, sets, and strings. For loop has the following syntax:\n",
    "\n",
    "```python\n",
    "for var in iterable:\n",
    "    statement\n",
    "```\n",
    "Let's look at an example of a for loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in [1, 2, 3, 4, 5]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the `range` function to do the same thing. `range` function takes three parameters: start(default 0), end, and steps (default 1). Like slicing, the start is inclusive but the end is exclusive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# 0 can be omitted.\n",
    "for i in range(6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Exercise Part 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before going into exercise, we need to learn a handy operation `+=`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 0\n",
    "a = a + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "is equivalent to "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 0\n",
    "a += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. The most exciting part about control flows is that they can be *nested* to make more complex algorithms. Let's look at the complementary DNA sequences that we discussed in lesson 1. Solve this problem using `for` and `if`. If you want, you can make a shorter answer using `for` and dictionary.\n",
    "\n",
    "> Create two new variables, comp_oligo1 and comp_oligo2, that are the complementary DNA sequences of oligo1 and oligo2 (hint: A <-> T and G <-> C)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "oligo1 = 'GCGCTCAAT'\n",
    "oligo2 = 'TACTAGGCA'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# backbone\n",
    "comp_oligo1 = ''\n",
    "for nuc in oligo1:\n",
    "    if nuc == 'A':\n",
    "        comp_oligo1 += 'T'\n",
    "    elif nuc == 'T':\n",
    "        comp_oligo1 += 'A'\n",
    "    elif nuc == 'C':\n",
    "        comp_oligo1 += 'G'\n",
    "    else:\n",
    "        comp_oligo1 += 'C'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# quicker answer\n",
    "comp_oligo1 = ''\n",
    "comp_dict = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}\n",
    "for nuc in oligo1:\n",
    "    comp_oligo1 += comp_dict[nuc]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'CGCGAGTTA'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "comp_oligo1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Let's go back to the dose-finding clinical trials. We have a list of doses that we want to test. `dose_list = [1, 2, 3, 5, 8, 13]`. We want to increase the dose until we hit the maximal tolerated dose (MTD). For simplicity, we will increase dose when there is less than two patients out of three patients with toxicity and stop otherwise. The last dose before at least two patients have toxicity is declared MTD. We will look into the future and assume that we know how many patients will have toxicity at each dose `tox_list = [0, 0, 1, 1, 2, 2]`. Find the MTD using `while`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "dose_list = [1, 2, 3, 5, 8, 13]\n",
    "tox_list = [0, 0, 1, 1, 2, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = 0\n",
    "while tox_list[i] < 2:\n",
    "    i += 1\n",
    "dose_list[i-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sources and References\n",
    "\n",
    "https://www.programiz.com/python-programming/list\n",
    "\n",
    "https://python.swaroopch.com/data_structures.html\n",
    "\n",
    "https://docs.python.org/3/tutorial/datastructures.html\n",
    "\n",
    "https://www.learnbyexample.org/python-tuple/"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "Lesson 2.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}