04-FunctionsBooleansConditionals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "317c8d94",
   "metadata": {},
   "source": [
    "# Functions, Booleans, Conditionals\n",
    "In this notebook, we'll encounter another type of variable, a **Boolean**. We'll talk about the ways that we can use conditionals, and begin writing functions. We'll ultimately put all of this together to write a program that can compute the GC content of a nucleotide sequence.\n",
    " \n",
    "## At the end of this notebook, you'll be able to:\n",
    "* [Write a simple function](#functions)\n",
    "* [Recognize and use different types of operators (Boolean and comparison)](#operators)\n",
    "* [Write and test conditional statements in Python](#conditionals)\n",
    "* [Use these tools to test the GC content in a DNA string](#GCcontent)\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acfb78a2",
   "metadata": {},
   "source": [
    "<a id=\"Functions\"></a>\n",
    "\n",
    "## Functions\n",
    "\n",
    "A function has the following syntax:\n",
    "\n",
    "```\n",
    "    def function():        \n",
    "        a*2\n",
    "        return a\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8039c234",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the function here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "070f9e99",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the function here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3802c26b",
   "metadata": {},
   "source": [
    "### Additional notes about functions\n",
    "* We can add docstrings to define a function, by adding a statement wrapped by `'''` after the function name. This will come up when you use `help(function)`.\n",
    "* Functions can have many, many lines!\n",
    "* Functions can call other functions.\n",
    "* A **program** is one or more functions that work together."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c72ea731",
   "metadata": {},
   "source": [
    "### Default function values\n",
    "If we usually want a function to work one way, but occasionally need it to do something else, we can allow people to pass a parameter when they need to but provide a default to make the normal case easier. The example below shows how Python matches values to parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b51cfc57",
   "metadata": {},
   "outputs": [],
   "source": [
    "def display(a=1, b=2, c=3):\n",
    "    print('a:', a, 'b:', b, 'c:', c)\n",
    "\n",
    "print('no parameters:')\n",
    "display()\n",
    "print('one parameter:')\n",
    "display(55)\n",
    "print('two parameters:')\n",
    "display(55, 66)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee946706",
   "metadata": {},
   "source": [
    "As this example shows, parameters are matched up from left to right, and any that haven’t been given a value explicitly get their default value. We can override this behavior by naming the value as we pass it in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edb4cf7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('only setting the value of c')\n",
    "display(c=77)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34ea8420",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<a id=\"Operators\"></a>\n",
    "   \n",
    "## Comparison and Boolean Operators\n",
    "\n",
    "We can use comparison operators to test the relationship between two objects. These statements return Booleans.\n",
    "\n",
    "**Booleans** are variables that store `True` or `False`. They are named after the British mathematician George Boole. He first formulated Boolean algebra, which are a set of rules for how to reason with and combine these values. This is the basis of all modern computer logic.\n",
    "\n",
    "**Note:** Capitalization *still* matters! TRUE is not a Boolean.\n",
    "\n",
    "\n",
    "| Symbol |    Operation   | Usage | Boolean Outcome |\n",
    "|:------:|:--------------:|:-----:|:-------:|\n",
    "|    ==   |  is equal to  |`10==5*2`| True | \n",
    "|    !=   | is not equal to | `10!=5*2` | False |\n",
    "|    >  | Greater than |  `10 > 2` | True |\n",
    "|    <   |    Less than    |  `10 < 2` | False |\n",
    "| >= | Greater than _or_ equal to | `10 >= 10` | True |\n",
    "| <= | Less than _or_ equal to | `10 >= 10` | True |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06ac9b16",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\"><b>Task:</b> Test each of the comparison operators, saving their output to a variable.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "250faf58",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test the comparison operators here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e1c5088",
   "metadata": {},
   "source": [
    "**Boolean operators** use Boolean logic, and include:\n",
    "- `and` : True if both are true\n",
    "- `or` : True if at least one is true\n",
    "- `not` : True only if false"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc4a9a91",
   "metadata": {},
   "source": [
    "What will this statement return?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ffc1c86e",
   "metadata": {},
   "outputs": [],
   "source": [
    "(6 > 10) and (4 == 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e455e4b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div class=\"alert alert-success\"><b>Task:</b> Test each of the Boolean operations <code>and</code>, <code>or</code>, & <code>not</code> to see how these variables relate, putting integers, floats, and conditional statements on each side.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa4f31a2",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Test Boolean operators here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a94fa36",
   "metadata": {},
   "source": [
    "### Short circuit evaluation!\n",
    "To determine the final result of an `and` expression, Python starts by evaluating the left operand. If it’s false, then the whole expression is false. In this situation, there’s no need to evaluate the operand on the right. Python already knows the final result. This is called **short circuit evaluation** and it saves Python time.\n",
    "\n",
    "Strings that contain any values return `True`. Strings that are empty (`''`) return `False`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09a61303",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\"><b>Task:</b> Test how Boolean operators work with strings, by testing <code>'a' and 'b'</code> and then <code>'b' and 'a'</code>.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9508c6a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test Boolean operators with strings\n",
    "\n",
    "'a' and 'b'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f36c931",
   "metadata": {},
   "source": [
    "<a id=\"conditionals\"></a>\n",
    "\n",
    "## Conditionals\n",
    "**Conditionals** are statements that check for a condition, using the `if` statement, and then only execute a set of code if the condition evaluates as `True`.\n",
    "\n",
    "- `if`\n",
    "- `elif` (else if): After an if, you can use elif statements to check additional conditions.\n",
    "- `else`: After an if, you can use an else that will run if the conditional(s) above have not run.\n",
    "\n",
    "### If/elif/else syntax\n",
    "- Indentation matters! Your statements in the `if` block need to be indented by a tab or four spaces.\n",
    "- You need a colon after `if`, `elif`, and `else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "862ddb57",
   "metadata": {},
   "outputs": [],
   "source": [
    "condition = False\n",
    "\n",
    "if condition:\n",
    "    print('This code executes if the condition evaluates as True.')\n",
    "    \n",
    "else: \n",
    "    print('This code executes if the condition evaluates as False')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e0034bb",
   "metadata": {},
   "source": [
    "### Properties of Conditionals\n",
    "- Conditionals can take any expression that can be evaluated as `True` or `False`. \n",
    "- The order of conditional blocks is always `if` then `elif`(s) then `else`.\n",
    "- If the `elif` is at the end, it will never be tested, as the else will have already returned a value once reached (and Python will throw an error).\n",
    "- An `else` statement is not required, but if both the `if` and the `elif` condtions are not met (both evaluate as `False`), then nothing is returned.\n",
    "- **At most one component (`if` / `elif` / `else`) of a conditional will run**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f24551eb",
   "metadata": {},
   "source": [
    "<a id=\"GCcontent\"></a>\n",
    "\n",
    "## Writing a program to count GC content\n",
    "\n",
    "Below, there is a function to calculate the GC content of a DNA string of length 4. It includes a few new elements that we haven't discussed, but can you see what it's doing?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15cd3814",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write our function\n",
    "\n",
    "def GCcontent4(DNA):\n",
    "    \n",
    "    '''counts GC content for a DNA string of length 4'''\n",
    "    \n",
    "    counter = 0 # Initialize counter\n",
    "    \n",
    "    if DNA[0]=='G' or DNA[0]=='C':\n",
    "        counter = counter+1\n",
    "    if DNA[1]=='G' or DNA[1]=='C':\n",
    "        counter = counter+1\n",
    "    if DNA[2]=='G' or DNA[2]=='C':\n",
    "        counter = counter+1\n",
    "    if DNA[3]=='G' or DNA[3]=='C':\n",
    "        counter = counter+1\n",
    "        \n",
    "    return counter/4.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63a0063a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call our function\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "748d4ea0",
   "metadata": {},
   "source": [
    "The `GCcontent4` uses **conditional statements** to test whether a given nucleotide in the sequence is equal to either a G or a C. In other words, it is doing a **value comparison**. If either of those conditions are met, it increments a **counter**. \n",
    "\n",
    "**Question**: Why can't we write `DNA[0] == 'C' or 'G'`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45760443",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e8b0fe4d",
   "metadata": {},
   "source": [
    "## Creating a function that catches errors\n",
    "If we put in a string that's not length 4, what happens?\n",
    "\n",
    "<div class=\"alert alert-success\"><b>Task:</b> Pseudocode a function (<code>GCcontent3or4</code>) that will work with strings of 3 or 4. Then, write your new function below.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3828ad9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your function here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49bcec88",
   "metadata": {},
   "source": [
    "Typically, we'll work with DNA strings that are longer than 4! What if we need to work with a longer string? Turns out, there's a good way to tackle this: a **for** loop. More on that in the next notebook.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42d140e6",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## Additional Resources\n",
    "* <a href=\"https://merely-useful.github.io/py/py-dev-development.html\">Merely Useful Functions</a>\n",
    "* <a href=\"https://www.python-course.eu/python3_functions.php\">Python Course: Functions</a>\n",
    "* <a href=\"https://swcarpentry.github.io/python-novice-plotting/17-conditionals/\">Software Carpentries Conditionals</a>\n",
    "\n",
    "## About this notebook\n",
    "* This notebook is largely derived from UCSD COGS18 Materials, created by Tom Donoghue & Shannon Ellis, as well as exercises in [*Computing for Biologists*](https://www.cambridge.org/highereducation/books/computing-for-biologists/5B08EEEE2AE8A602113A8F225E89F5FD#overview)."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}