day_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python for Biology\n",
    "# Day 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "week = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say we want to print out each element of our list of days along with a message. We could do it this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today is Monday\n",
      "Today is Tuesday\n",
      "Today is Wednesday\n",
      "Today is Thursday\n",
      "Today is Friday\n",
      "Today is Saturday\n",
      "Today is Sunday\n"
     ]
    }
   ],
   "source": [
    "print(\"Today is \" + week[0])\n",
    "print(\"Today is \" + week[1])\n",
    "print(\"Today is \" + week[2])\n",
    "print(\"Today is \" + week[3])\n",
    "print(\"Today is \" + week[4])\n",
    "print(\"Today is \" + week[5])\n",
    "print(\"Today is \" + week[6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is really repetitive and requires that I know how many elements are in my list. In programming, when you feel yourself repeating yourself like this, check if there is a way to make it easier on yourself. D.R.Y. (Don't Repeat Yourself). Also, if we wanted to change some of the code, we would have to go in and do it seven times. \n",
    "\n",
    "So, we can use Python's loop syntax (grammar) to say:\n",
    "*For each element in the list of days, print out the words \"Today is \" followed by the list element.\n",
    "\n",
    "That looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's break this down. It starts with `for item in list`, where `item` is a variable name we make up and `list` is the name of the list we are looping through. We can use the name `item` (or whatever we called it) to refer to that element within our loop. \n",
    "\n",
    "We end this first line with a colon, and we indent all of the lines after that. Indents can actually be any number of tab or space characters, but we need to make sure we are consistent. This tabbed part indicates that it belongs to the loop, and we call it the **body** of the loop. Each time we go through the loop, the body will be executed on that new element. The body can contain more than one line of code (each will be executed for each item). \n",
    "\n",
    "We can make a loop that is a bit more complicated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice above that I use a string variable like a list above and used the indexing we learned earlier on it. We can treat strings like we do lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings have their own special methods just like lists do. We'll play with these more tomorrow!\n",
    "\n",
    "We can also use looping to iterate over lines in a file or over files in a folder. More on that tomorrow as well!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also us for loops to iterate over a list of numbers using `range()`. If we use one argument in range, it will count from zero up to and not including that number. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add a second argument to have it count from the first number up to and not including the second number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we add a third argument, the third number will be the step-size (what it will count by)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to store **key-value pairs**, we can use a dictionary. In other programming languages, they sometimes go by other names, like associative array. Instead of being indexed by a number like a list, they are indexed by their key name.\n",
    "\n",
    "Dictionaries can only store keys strings and numbers. So we can't make file objects our keys. Values can be whatever we like. Note that keys must be unique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create an empty dictionary and add elements to it. (This might be more likely what we do in our own programs)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to remove an item from the dicitonary, we can use the `.pop()` method. This will return the value and delete the key. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can iterate over a dictionary. Dictionaries are unordered. \n",
    "\n",
    "We can iterate using the `.keys()` method, which returns the keys of the dictionary. The `.get()` method will return the value of that key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or using the `.items()` method to get both keys and values. This method returns two values, which is new for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we want our program to make decisions. For this we can use conditions, which test give us a true or false answer to a question we ask. Let's try this out and test some conditions. We get a **Boolean** returned to us (not a string). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To test if something is equal to, we use two equal signs (not one--that would be variable assignment)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To test is something is not equal to, we use `!=` (we call exclamation points \"bangs\" in programming). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also test if numbers are greater than or less than (> and <) or greater than or equal to/less than or equal to (>= and <=)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use `in` to see if a value is in a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also methods that return a Boolean, like `.startswith()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use these condition statements with an `if` statement to create a decision point on whether or not a block of code is executed. Write the word `if` followed by a condition, and end that line with a colon. Then the next line starts a block of code, so indent it (remember this from looping). The code block will only run if the condition is true. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's loop through a list and check on values. We'll have to use multiple levels of indentation. We can have as many level of indentation as we need, but if we end up with more than three levels, it might be an indicator that we should turn the code into a function. More on functions later!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures = [100, 54, 98, 120, 130, 0, -2, -13]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`else` is used to run a block of code if the `if` condition is false. `else` and `if` will be at the same level of indentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to add more than two possible branches, we can add as many `elif` statements to check for other conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures = [100, 54, 98, 120, 130, 0, -2, -13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Independent Work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recommendations for weather conditions \n",
    "\n",
    "1. The temperature is higher than 15 degrees and it is raining: Bring an umbrella.  \n",
    "2. The temperature is lower than or equal to 15 degrees and it is raining: Bring an umbrella and a jacket.  \n",
    "3. The temperature is higher than 15 degrees and the sun is shining: Wear a T-shirt.  \n",
    "4. The temperature is lower than or equal to 15 degrees and the sun is shining: Bring a jacket. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterate from 1 to 30 with the following instructions:  \n",
    "If a number is divisible by 3, print 'fizz'.  \n",
    "If a number is divisible by 5, print 'buzz'.  \n",
    "If a number is both divisible by 3 and 5 print 'fizzbuzz'.  \n",
    "Otherwise, print just the number.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bonus Problem: Iterate through the animals. Print out the animal name and the number of vowels in the name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = ['duck', 'rat', 'boar', 'slug', 'mammoth', 'gazelle']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bonus Problem: DNA Sequence Trimming/Counting\n",
    "\n",
    "Here we have some made-up DNA sequences, one on each line. Write a program that trims off the 14 base pair (letter) from the beginning of the sequence. Print the cleaned sequence and the length of the sequence. \n",
    "\n",
    "ATTCGATTATAAGCTCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATC\n",
    "\n",
    "ATTCGATTATAAGCACTGATCGATCGATCGATCGATCGATGCTATCGTCGT\n",
    "\n",
    "ATTCGATTATAAGCATCGATCACGATCTATCGTACGTATGCATATCGATATCGATCGTAGTC\n",
    "\n",
    "ATTCGATTATAAGCACTATCGATGATCTAGCTACGATCGTAGCTGTA\n",
    "\n",
    "ATTCGATTATAAGCACTAGCTAGTCTCGATGCATGATCAGCTTAGCTGATGATGCTATGCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}