Intro_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"images/python-logo-master.png\" style=\"width:25%;height:25%\"></img>\n",
    "# Introduction to Python\n",
    "\n",
    "## School of Medicine Research Computing\n",
    "**Christina Gancayco**<br>\n",
    "**September 27, 2018**<br>\n",
    "**gancayco@virginia.edu**<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Free Workshops at UVA\n",
    "### <a hyperlink=\"https://education.cadre.virginia.edu/\">https://education.cadre.virginia.edu/</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What Can You Do With Python?\n",
    "* **Data Science**: data analysis (pandas), data visualization (matplotlib, bokeh, seaborn), machine learning (TensorFlow, Keras)\n",
    "* **Bioinformatics** with Biopython\n",
    "* **Web Development** with Django and Flask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Outline\n",
    "* Jupyter Notebooks\n",
    "* Anaconda and Spyder\n",
    "* Math and Variables\n",
    "* Loops\n",
    "* Logics and Conditionals\n",
    "* Functions\n",
    "* Modules\n",
    "* File I/O\n",
    "* Function Documentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"images/jupyter.png\" style=\"width:20%;height:20%\"></img>\n",
    "## Jupyter Notebooks\n",
    "\n",
    "Jupyter is a Python package and web-based notebook environment for interactive computing. It's great for combining code and rich text elements, which can be useful for sharing descriptions of an analysis and its results. Users can run data analysis in real-time. These slides are a Jupyter Notebook!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### How To Use the Jupyter Notebook\n",
    "\n",
    "* A cell is a section of the Jupyter Notebook. Click on a cell to edit code.\n",
    "* Run a cell and the code within it, click the Run button in the toolbar or press Shift + Enter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Anaconda and Spyder\n",
    "\n",
    "### <a hyperlink=\"https://www.anaconda.com/\">https://www.anaconda.com/</a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"images/logo-anaconda.png\" style=\"width:20%;height:20%\"></img>\n",
    "### Anaconda Navigator\n",
    "\n",
    "Anaconda is an open source distribution of Python (and R!) distribution for data analysis and for simplifying package management and deployment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"images/spyder_bbg.png\"></img>\n",
    "\n",
    "### Spyder\n",
    "Spyder (Scientific PYthon Development EnviRonment) is the IDE packaged with Anaconda. This is where you will typically develop and run code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Let's Get Started: Hello World!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Hashes are used to comment code\n",
    "# Anything following a hash is not executed\n",
    "\n",
    "# The print() command is used to print whatever is within the parentheses to the console.\n",
    "# Let's try printing \"Hello World!\"\n",
    "\n",
    "print(Hello World!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Output\n",
    "\n",
    "        File \"<ipython-input-2-fd1ff2177085>\", line 7\n",
    "          print(Hello World!)\n",
    "                          ^\n",
    "    SyntaxError: invalid syntax\n",
    "        \n",
    "**Don't be afraid of errors! They can tell you what to fix.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's try printing \"Hello World!\" again.\n",
    "# This time we will put \"Hello World!\" inside quotation marks.\n",
    "\n",
    "print(\"Hello World!\")\n",
    "\n",
    "# Try printing \"Thank you!\" below!\n",
    "# Simply replace None with \"Thank you!\" in the code below.\n",
    "#### START CODE HERE (1 line of code) ####\n",
    "\n",
    "print(None)\n",
    "\n",
    "#### END CODE HERE ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Output\n",
    "    Hello World!\n",
    "    Thank you!\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Math Operations\n",
    "\n",
    "<table style=\"width:300px\">\n",
    "<th><p style=\"font-size:16pt;font-style:bold\">Symbol</p></th><th><p style=\"font-size:16pt;font-style:bold\">Operation</p></th>\n",
    "<tr><td><p style=\"font-size:16pt\"><b>+</b></p></td><td><p style=\"font-size:12pt\">Addition</p></td></tr>\n",
    "<tr><td><p style=\"font-size:16pt\"><b>-</b></p></td><td><p style=\"font-size:12pt\">Subtraction</p></td></tr>\n",
    "<tr><td><p style=\"font-size:16pt\"><b>\\*</b></p></td><td><p style=\"font-size:12pt\">Multiplication</p></td></tr>\n",
    "<tr><td><p style=\"font-size:16pt\"><b>/</b></p></td><td><p style=\"font-size:12pt\">Division</p></td></tr>\n",
    "<tr><td><p style=\"font-size:16pt\"><b>\\*\\*</b></p></td><td><p style=\"font-size:12pt\">Exponent</p></td></tr>\n",
    "<tr><td><p style=\"font-size:16pt\"><b>%</b></p></td><td><p style=\"font-size:12pt\">Modulus</p></td></tr>\n",
    "<tr><td><p style=\"font-size:16pt\"><b>//</b></p></td><td><p style=\"font-size:12pt\">Floor Division</p></td></tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's try some math.\n",
    "\n",
    "1+1\n",
    "2+3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Output\n",
    "    Out[3]: 5\n",
    "_(Don't worry if your number in \"Out[ ]\" doesn't match the one above. This is just the number of code blocks you've run so far.)_\n",
    "\n",
    "We see the output of `2+3`, but where is the output of `1+1`? Python doesn't automatically print your results to the console. In order to see our results, we have to use the `print` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's try some more math operations.\n",
    "print(1+2.3)   # addition\n",
    "print(4-5)     # subtraction\n",
    "print(67*7.8)  # multiplication\n",
    "print(9.0/1.2) # division\n",
    "print(3**4)    # exponent\n",
    "print(12%7)    # modulus, or remainder\n",
    "print(12//7)   # floor division (rounds down to nearest integer)\n",
    "\n",
    "# Order of operations applies!\n",
    "print(1-(2*4)/2)\n",
    "\n",
    "# Try printing the result of 0.5*50+7.\n",
    "# Replace None with the correct mathematical expression in the code below.\n",
    "#### START CODE HERE (1 line of code) ####\n",
    "\n",
    "print(None)\n",
    "\n",
    "#### END CODE HERE ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Output\n",
    "    3.3\n",
    "    -1\n",
    "    522.6\n",
    "    7.5\n",
    "    81\n",
    "    5\n",
    "    1\n",
    "    -3.0\n",
    "    32.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variables and Data Types\n",
    "\n",
    "_Variables are where you store your values._\n",
    "\n",
    "---\n",
    "**Variable Rules**\n",
    "1. Variable names must start with a letter or a single underscore.\n",
    "2. Variable names can contain letters, underscores, and numbers.\n",
    "3. Variable names are case-sensitive. (myvar is not the same as myVar)\n",
    "4. Variable names can't be any of these keywords: [https://www.programiz.com/python-programming/keywords-identifier](https://www.programiz.com/python-programming/keywords-identifier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's try creating some variables\n",
    "\n",
    "x = 1\n",
    "\n",
    "# Keep in mind, the \"=\" sign does not mean \"equals\".\n",
    "# \"=\" is assigning the value to the right to the variable name on the left.\n",
    "print(x)\n",
    "x = x + 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Output\n",
    "    1\n",
    "    2\n",
    "\n",
    "`x` now has a value of 2 because we updated its value with the original value of `x` + 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# We can add the values assigned to variables and assign the result to a new variable.\n",
    "\n",
    "# Try creating a variable \"y\" with a value of 5 and assigning the sum of x and y to a new variable \"myVar\".\n",
    "# (x from the previous example still exists)\n",
    "#### START CODE HERE (2 lines of code) ####\n",
    "y = None\n",
    "myVar = None\n",
    "#### END CODE HERE ####\n",
    "\n",
    "print(myVar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Output\n",
    "    7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variables and Data Types\n",
    "_Values assigned to variables have a data type._\n",
    "\n",
    "<table style=\"width:600px\">\n",
    "<th><p style=\"font-size:18pt\">Data Type</p></th><th><p style=\"font-size:18pt\">Definition</p></th>\n",
    "<tr><td><p style=\"font-size:14pt\">`int`</p></td><td><p style=\"font-size:14pt\">integer</p></td></tr>\n",
    "<tr><td><p style=\"font-size:14pt\">`float`</p></td><td><p style=\"font-size:14pt\">floating point (decimal)</p></td></tr>\n",
    "<tr><td><p style=\"font-size:14pt\">`str`</p></td><td><p style=\"font-size:14pt\">string (letter or number characters)</p></td></tr>\n",
    "<tr><td><p style=\"font-size:14pt\">`bool`</p></td><td><p style=\"font-size:14pt\">boolean `True` or `False`</p></td></tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Are values with the same numerical value but different data types equal?\n",
    "# Let's check:\n",
    "# The ; separates commands in the same line\n",
    "googol = 1.0e100; print(googol); print(type(googol)) # the type() command returns the data type of the variable\n",
    "googol_int = 10**100; print(googol_int); print(type(googol_int))\n",
    "\n",
    "print(googol_int - googol)\n",
    "\n",
    "# The \"==\" is a comparison, or relational, operator.\n",
    "# This will return \"True\" if googol is equal to googol_int, and \"False\" otherwise.\n",
    "print(googol == googol_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Output\n",
    "    1e+100\n",
    "    <class 'float'>\n",
    "    10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n",
    "    <class 'int'>\n",
    "    0.0\n",
    "    False\n",
    "    \n",
    "Even though `googol` and `googol_int` contain the same numerical value, they are not equal because they are different data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's play with string variables.\n",
    "\n",
    "firstName = \"Bilbo\"\n",
    "lastName = \"Baggins\"\n",
    "\n",
    "# We can concatenate strings horizontally by using \"+\"\n",
    "myName = firstName + \" \" + lastName\n",
    "print(myName)\n",
    "\n",
    "# We can also use comparison operations on strings.\n",
    "print(\"chocolate\" > \"broccoli\")\n",
    "\n",
    "# When used with string variables, \">\" and \"<\" determine alphabetical order.\n",
    "# With \">\", \"True\" is returned when the string on the left comes later in the alphabet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Now let's try Booleans.\n",
    "\n",
    "python_is_fun = True\n",
    "python_is_boring = False\n",
    "\n",
    "# Can we perform mathematical operations on booleans?\n",
    "print(python_is_fun + python_is_boring)\n",
    "print(python_is_fun + 3)\n",
    "\n",
    "# Yes! \"True\" has a value of 1, and \"False\" has a value of 0.\n",
    "# This can be very useful when coding conditionals, which we will discuss later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sequence Data Types\n",
    "\n",
    "* These data types can contain multiple values, and have an intrinsic order.\n",
    "* Individual values can be accessed with indexing and slicing.\n",
    "\n",
    "<table style=\"width:600px\">\n",
    "<th><p style=\"font-size:18pt\">Data Type</p></th><th><p style=\"font-size:18pt\">Definition</p></th>\n",
    "<tr><td><p style=\"font-size:14pt\">`list` [...]</p></td><td><p style=\"font-size:12pt\">contains values that can be changed (mutable)</p></td></tr>\n",
    "<tr><td><p style=\"font-size:14pt\">`tuple` (...)</p></td><td><p style=\"font-size:12pt\">contains values that cannot be changed (immutable)</p></td></tr>\n",
    "<tr><td><p style=\"font-size:14pt\">`str` \"...\"  or '...' or '''...'''</p></td><td><p style=\"font-size:12pt\">string (`apple` is not the same as `leppa`)</p></td></tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Indexing\n",
    "\n",
    "#### Extract a single element of a sequence\n",
    "\n",
    "<img src=\"images/indexing.png\" style=\"width:75%;height:75%\"></img>\n",
    "\n",
    "Each character of the string has two index numbers, shown above and below each box."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's create some sequences.\n",
    "\n",
    "# Here is our list.\n",
    "my_list = [1, 1, 2, 3, 5, 8]\n",
    "\n",
    "# Let's print the first value of my_list to the console.\n",
    "print(my_list[0])\n",
    "\n",
    "# Try printing the last value of list to the console.\n",
    "#### START CODE HERE (1 line of code) ####\n",
    "\n",
    "print(None)\n",
    "\n",
    "#### END CODE HERE #####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Outcome\n",
    "\n",
    "    1\n",
    "    8\n",
    "    \n",
    "There are two ways you could obtain the last value of `my_list`.\n",
    "\n",
    "1. `my_list[5]`\n",
    "2. `my_list[-1]`\n",
    "\n",
    "The second method will always return the last element of a sequence and is more practical since the size of my_list could change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# my_list is a Fibonacci sequence. Let's add the next value to the end of my_list.\n",
    "\n",
    "# To add a value to the end of a list, use the append function.\n",
    "\n",
    "my_list.append(my_list[-2] + my_list[-1])\n",
    "\n",
    "# Now if we print my_list, we should see the value 13 at the end.\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# What if we tried the same thing with a tuple? Let's see what happens.\n",
    "\n",
    "my_tuple = (1, 1, 2, 3, 5, 8)\n",
    "\n",
    "my_tuple.append(my_tuple[-2] + my_tuple[-1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Output\n",
    "\n",
    "```\n",
    "---------------------------------------------------------------------------\n",
    "AttributeError                            Traceback (most recent call last)\n",
    "<ipython-input-11-5a2fbed28f7f> in <module>()\n",
    "      3 my_tuple = (1, 1, 2, 3, 5, 8)\n",
    "      4 \n",
    "----> 5 my_tuple.append(my_tuple[-2] + my_tuple[-1])\n",
    "\n",
    "AttributeError: 'tuple' object has no attribute 'append'```\n",
    "\n",
    "Tuples cannot be modified."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Slicing\n",
    "\n",
    "Extracting consecutive elements of a sequence\n",
    "\n",
    "\n",
    "<img src=\"images/indexing.png\" style=\"width:75%;height:75%\"></img>\n",
    "\n",
    "A slice is a subset of consecutive elements in a sequence, denoted by the gray boxes above.\n",
    "\n",
    "To reference a slice, we use the syntax **\\[from:up to but not including\\]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's take a slice of the first three values of my_list and assign it to a variable my_slice.\n",
    "\n",
    "my_slice = my_list[0:3]\n",
    "\n",
    "print(my_slice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Collection Data Types\n",
    "\n",
    "* These data types contain multiple values and have no intrinsic order.\n",
    "* These data types do not have numerical indices.\n",
    "\n",
    "<table style=\"width:600px\">\n",
    "<th><p style=\"font-size:18pt\">Data Type</p></th><th><p style=\"font-size:18pt\">Definition</p></th>\n",
    "<tr><td><p style=\"font-size:14pt\">`set {...}`</p></td><td><p style=\"font-size:12pt\">contains unique values</p></td></tr>\n",
    "<tr><td><p style=\"font-size:14pt\">`dictionary {...:...}`</p></td><td><p style=\"font-size:12pt\">contains unique key pairs</p></td></tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's create a set.\n",
    "\n",
    "my_set = {1, 2, 3, 4}\n",
    "print(my_set)\n",
    "\n",
    "# What if we give my_set repeating values?\n",
    "my_set = {1, 1, 2, 2}\n",
    "print(my_set)\n",
    "\n",
    "# Sets can only contain unique values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's create a dictionary for DNA base pairs.\n",
    "\n",
    "dna_basepairs = {\"A\": \"T\", \"C\": \"G\"}\n",
    "\n",
    "# How do we access the complement of base A?\n",
    "print(dna_basepairs[\"A\"])\n",
    "\n",
    "# What if we try to access the complement of base T?\n",
    "print(dna_basepairs[\"T\"])\n",
    "\n",
    "# Dictionary key pairs are one-directional. You cannot access keys from values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's print out each base complement\n",
    "dna_basepairs = {\"A\": \"T\", \"C\": \"G\", \"G\": \"C\", \"T\": \"A\"}\n",
    "\n",
    "print(dna_basepairs[\"A\"])\n",
    "print(dna_basepairs[\"C\"])\n",
    "print(dna_basepairs[\"G\"])\n",
    "print(dna_basepairs[\"T\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## For Loops\n",
    "Execute code iteratively\n",
    "<img src=\"images/for-loop.png\" style=\"width:30%;height:30%\"></img>\n",
    "\n",
    "**IMPORTANT! Code within a for loop must be indented with four spaces or a tab.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# That was a lot of lines of code! Let's use a for loop instead.\n",
    "for pair in dna_basepairs:                   # pair is our iterating variable, dna_basepairs is our sequence\n",
    "    print(dna_basepairs[pair])\n",
    "    \n",
    "# You can also iterate a for loop over index numbers\n",
    "# Let's a create a list of numbers 0 through 9 (10 numbers total).\n",
    "my_nums = []\n",
    "for x in range(10):\n",
    "    my_nums.append(x)\n",
    "\n",
    "print(my_nums)\n",
    "\n",
    "# Statements within a for loop must be indented with four spaces or a tab!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Practice Exercise: DNA Complement\n",
    "\n",
    "<img src=images/dna-complement.gif></img>\n",
    "\n",
    "You are given a nucleotide sequence: ATG GTG AGC AAG. Write code to determine and print the complementary sequence.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Practice Exercise: DNA Complement\n",
    "\n",
    "# Nucleotide dictionary\n",
    "dna_basepairs = {\"A\": \"T\", \"C\": \"G\", \"G\": \"C\", \"T\": \"A\"}\n",
    "\n",
    "# Input DNA strand\n",
    "myDNA = \"ATGGTGAGCAAG\"\n",
    "comp_seq = \"\"\n",
    "\n",
    "# Determine and print the complementary sequence of myDNA.\n",
    "# You will use a for loop and string concatenation (\"str1\" + \"str2\").\n",
    "# Remember your indentation!\n",
    "#### START CODE HERE (3 lines of code) ####\n",
    "\n",
    "\n",
    "#### END CODE HERE ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Output\n",
    "\n",
    "    TACCACTCGTTC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## While Loops (Conditional Looping)\n",
    "\n",
    "<img src=\"images/while-loop.png\" style=\"width:30%;height:30%\"></img>\n",
    "\n",
    "**A condition** is a comparison operation that returns a boolean. If `True`, the code in the while loop will be executed. If `False`, the while loop is finished running."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# While Loop Example\n",
    "\n",
    "# Let's create a variable called counter that starts at 0 and has 1 added to it until it equals 10.\n",
    "# Again, we use indentation for code we want to execute within the loop.\n",
    "\n",
    "counter = 0\n",
    "\n",
    "while counter < 10:\n",
    "    counter = counter + 1\n",
    "    print(\"counter = \",counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## If Statements\n",
    "\n",
    "Conditionally execute code\n",
    "\n",
    "<img src=\"images/if-statement.png\" style=\"width:30%;height:30%\"></img>\n",
    "\n",
    "Like the while loop, code within the if statement will only run when the condition is `True`.\n",
    "Again indentation is used to denote code within the if statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's create a variable x.\n",
    "x = 25\n",
    "print(\"original x =\",x)\n",
    "\n",
    "# If x is odd, let's add 1 to it.\n",
    "\n",
    "if x%2 == 1:\n",
    "    x = x + 1\n",
    "\n",
    "print(\"new x =\",x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Else and Else If Statements\n",
    "\n",
    "What if we want to run certain code if the condition isn't true? What if we want to run different code if a different condition is met?\n",
    "\n",
    "<img src=\"images/else.png\" style=\"width:25%;height:25%\"></img>\n",
    "\n",
    "`else`: run code when the condition is `False`<br>\n",
    "`elif`: run code when a different condition is `True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# If, Else, and Elif Example\n",
    "\n",
    "x = 13.5\n",
    "\n",
    "# 1. When x is odd, add 1 to x.\n",
    "# 2. When x is even, divide x by 2.\n",
    "# 3. If x is neither even nor odd, round it to the nearest integer.\n",
    "\n",
    "# Feel free to adjust x to see which conditional code runs!\n",
    "\n",
    "if x%2 == 1:\n",
    "    x = x+1\n",
    "elif x%2 == 0:\n",
    "    x = x/2\n",
    "else:\n",
    "    x = round(x)\n",
    "    \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Practice Exercise: RNA Transcription\n",
    "\n",
    "<img src=\"images/rna-transcription.gif\"></img>\n",
    "\n",
    "Let's take our code from the DNA complement exercise and determine the RNA complement instead.\n",
    "\n",
    "So if the base is \"A\", let's add a \"U\" to the comp_seq instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Practice Exercise: RNA Transcription\n",
    "\n",
    "# Nucleotide dictionary\n",
    "dna_basepairs = {\"A\": \"T\", \"C\": \"G\", \"G\": \"C\", \"T\": \"A\"}\n",
    "\n",
    "# Input DNA strand\n",
    "myDNA = \"ATGGTGAGCAAG\"\n",
    "comp_seq = \"\"\n",
    "\n",
    "# You will use an if/else statement within the for loop.\n",
    "# Be careful with your indentation!\n",
    "for base in myDNA:\n",
    "    #### START CODE HERE (4 lines of code) ####\n",
    "\n",
    "        \n",
    "    #### END CODE HERE ####\n",
    "    \n",
    "print(comp_seq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Expected Output\n",
    "\n",
    "    UACCACUCGUUC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions\n",
    "What if we want to use code we've already written in future scripts?\n",
    "\n",
    "Functions allow us to reuse code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Function Example\n",
    "\n",
    "# Let's create a function for the previous RNA transcription example.\n",
    "myDNA = \"ATGGTGAGCAAG\"\n",
    "\n",
    "# use def to define your function, my_func is the name, and the () is where you put any input arguments\n",
    "def my_func(DNA_seq):\n",
    "    \n",
    "    dna_basepairs = {\"A\": \"T\", \"C\": \"G\", \"G\": \"C\", \"T\": \"A\"}\n",
    "    comp_seq = \"\"\n",
    "    \n",
    "    for base in DNA_seq:\n",
    "        if base == \"A\":\n",
    "            comp_seq = comp_seq + \"U\"\n",
    "        else:\n",
    "            comp_seq = comp_seq + dna_basepairs[base]\n",
    "    \n",
    "    return comp_seq      # return dictates which variables are outputs\n",
    "\n",
    "print(my_func(myDNA))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Modules\n",
    "\n",
    "Modules are .py files containing pre-defined functions. You can create your own modules, and import modules from the thousands of Python packages available online.\n",
    "\n",
    "Popular packages include:\n",
    "* **math**: math functions defined by C standard\n",
    "* **NumPy**: scientific computing\n",
    "* **pandas**: data manipulation\n",
    "* **matplotlib**: plotting\n",
    "* **TensorFlow**: machine learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Importing Modules\n",
    "\n",
    "# There are multiple ways you can import a module.\n",
    "\n",
    "# 1. Import as-is\n",
    "import numpy\n",
    "print(numpy.sqrt(4))\n",
    "\n",
    "# 2. Shorten the name of the module\n",
    "import numpy as np\n",
    "print(np.sqrt(9))\n",
    "\n",
    "# 3. Import the function from the module\n",
    "from numpy import sqrt\n",
    "print(sqrt(16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# File I/O\n",
    "\n",
    "# Reading data from a file\n",
    "\n",
    "# Method 1\n",
    "f1 = open(\"my_sequences.txt\",\"r\")   # opening the file for reading (\"r\")\n",
    "for row in f1:\n",
    "    print(row)\n",
    "f1.close()                     # closing the file, necessary if you open using the equal sign\n",
    "\n",
    "# Method 2\n",
    "with open(\"my_sequences.txt\",\"r\") as f2:  # using \"with\", the close function is not necessary\n",
    "    for row in f2:\n",
    "        print(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# File I/O\n",
    "\n",
    "# Writing data to files\n",
    "\n",
    "# Let's use our RNA transcription function \"my_func\" from the last exercise to determine the RNA complement\n",
    "# of the sequences from my_sequences.txt. We'll write our results to a text file called my_complements.txt.\n",
    "\n",
    "with open(\"my_sequences.txt\",\"r\") as fi:    # my_sequences.txt is opened for reading\n",
    "    with open(\"my_complements.txt\", \"a\") as fo:  # a new file my_complements.txt is opened for writing with appending\n",
    "        for row in fi:                      # for each row in my_sequences.txt...:\n",
    "            my_seq = row.upper().rstrip()   # upper capitalizes the dna sequence, rstrip removes the line ending code\n",
    "            comp_seq = my_func(my_seq)      # runs our RNA transcription function\n",
    "            fo.write(comp_seq+\"\\n\")         # writes comp_seq and newline code to my_complements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Function Documentation\n",
    "\n",
    "# To learn more about a module or function:\n",
    "\n",
    "help(print)\n",
    "\n",
    "# or\n",
    "\n",
    "print?"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.3"
  },
  "livereveal": {
   "autolaunch": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}