04-BooleansConditionalsLoops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming Fundamentals III\n",
    "\n",
    "### Booleans, Conditionals, Loops\n",
    "\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 loops."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## At the end of this notebook, you'll be able to:\n",
    "* Write Boolean logic statements\n",
    "* Recognize different types of operators (conditional, identity, and membership)\n",
    "* Test conditional statements in Python\n",
    "* Write a simple loop\n",
    "* Write a simple function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Booleans\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 matters! TRUE is not a Boolean."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool_1 = True\n",
    "bool_2 = False\n",
    "\n",
    "bool_1 and not bool_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Conditional operators\n",
    "Condition operators can be used to test the relationship between two objects. These operators return Booleans.\n",
    "\n",
    "| Symbol |    Operation   | Usage | 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",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div class=\"alert alert-success\"><b>Task:</b> Test each of conditional operations, saving their output to a variable. Then, check the type of these variables. Use <code>and</code>, <code>or</code>, & <code>not</code> to see how these variables relate.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 >= 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Identity Operators\n",
    "\n",
    " Identity operators are used to check if two values (or variables) are located on the same part of the memory.\n",
    " \n",
    "- `is` : True if both refer to the same object\n",
    "- `is not` : True if they do not refer to the same object\n",
    "\n",
    "**Hint**: You can use the `id` function to check the unique identifier of a Python object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "4593312176\n",
      "4593312176\n",
      "4593311984\n"
     ]
    }
   ],
   "source": [
    "a = 927\n",
    "b = a\n",
    "c = 927\n",
    "print(a is b)\n",
    "print(c is a)\n",
    "\n",
    "print(id(a))\n",
    "print(id(b))\n",
    "print(id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    " As demonstrated above, two variables that are equal does **not** imply that they are identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# testing for value equality\n",
    "a == b == c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Membership Operators\n",
    "Python uses `in` and `not in` to compare membership. These operators return booleans. Membership operators are used to check whether a value or variable is found in a sequence.\n",
    "\n",
    "- `in` : True if value is found in the sequence\n",
    "- `not in` : True if value is not found in the sequence\n",
    "\n",
    "We can use this to check for membership in strings, as well as in lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 'I love BIPN162!'\n",
    "print('loved' in x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Chaining Operators\n",
    "Operators and variables can also be chained together into arbitrarily complex expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note that you can use parentheses to chunk sections\n",
    "(13 % 7 >= 7) and ('BIPN' + '162' == 'BIPN162')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 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",
    "\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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 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": 26,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This code executes if the condition evaluates as False\n"
     ]
    }
   ],
   "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": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This code executes if condition_1 evaluates as True.\n",
      "This code executes if condition_2 evaluates as True.\n",
      "This code executes if both condition_1 and condition_2 evaluate as True\n"
     ]
    }
   ],
   "source": [
    "condition_1 = True\n",
    "condition_2 = True\n",
    "\n",
    "if condition_1:\n",
    "    print('This code executes if condition_1 evaluates as True.')\n",
    "if condition_2:\n",
    "    print('This code executes if condition_2 evaluates as True.')\n",
    "if condition_1 and condition_2: \n",
    "    print('This code executes if both condition_1 and condition_2 evaluate as True')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This code executes if both condition_1 and condition_2 evaluate as False\n"
     ]
    }
   ],
   "source": [
    "condition_1 = False\n",
    "condition_2 = False\n",
    "\n",
    "if condition_1:\n",
    "    print('This code executes if condition_1 evaluates as True.')\n",
    "elif condition_2:\n",
    "    print('This code executes if condition_1 did not evaluate as True, but condition_2 does.')\n",
    "else: \n",
    "    print('This code executes if both condition_1 and condition_2 evaluate as False')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conditionals With Value Comparisons\n",
    "\n",
    "Any expression that can be evaluated as a boolean, such as value comparisons, can be used with conditionals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yay!\n"
     ]
    }
   ],
   "source": [
    "language = \"Python\"\n",
    "\n",
    "if language == \"Python\":\n",
    "    print(\"Yay!\")\n",
    "elif language == \"MATLAB\" or language == \"R\":\n",
    "    print(\"Oh no.\")\n",
    "else:\n",
    "    print(\"Get yourself a programming language!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before Conditional\n",
      "    elif statement execution\n",
      "After Conditional\n"
     ]
    }
   ],
   "source": [
    "# Exploring conditionals\n",
    "number = 6\n",
    "\n",
    "print('Before Conditional')\n",
    " \n",
    "if number < 5:\n",
    "    print('    if statement execution')\n",
    "elif number > 5:\n",
    "    print('    elif statement execution')\n",
    "\n",
    "print('After Conditional')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Counters\n",
    "Sometimes it's useful to set up a <b>counter</b> so that you know how many times a piece of code has run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# Initialize a counter variable\n",
    "#counter = 0 \n",
    "print(counter)\n",
    "\n",
    "counter = counter + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Question**: What will be the value of `counter` after this code is run?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python is good\n",
      "length is 4\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "things_that_are_good = ['python', 'data', 'science', 'tacos']\n",
    "\n",
    "counter = 0\n",
    "\n",
    "if 'python' in things_that_are_good:\n",
    "    print('python is good')\n",
    "    counter = counter + 1\n",
    "\n",
    "if len(things_that_are_good) == 4:\n",
    "    print('length is 4')\n",
    "    counter = counter + 1\n",
    "    \n",
    "if things_that_are_good[2] == 'data':\n",
    "    print('data was index 2')\n",
    "    counter = counter + 1 \n",
    "    \n",
    "print(counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div class=\"alert alert-success\"><font color=\"blue\"><b>Task: Guessing Game Challenge</b></font>\n",
    "Ask the user: “What’s my favorite food?”\n",
    "    <i>If</i> it’s the same as yours, respond, “Yep, delicious!”\n",
    "<i>If not</i>, say “Nope, you’re wrong.”\n",
    "Regardless, tell the user “Thanks for playing.”\n",
    "\n",
    "**Hint**: You can use the `input` function to ask the user for a string input. For example, `response = input(\"What's my name?\")`\n",
    "\n",
    "Working with a team, pseudocode this on the whiteboard, and then write this code in the block below.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's my favorite food?pizza\n",
      "great\n",
      "thanks for playing.\n"
     ]
    }
   ],
   "source": [
    "response = input('What\\'s my favorite food?')\n",
    "fave_foods = ['apple','bananas','pizza']\n",
    "if response.lower() in fave_foods:\n",
    "    print('great')\n",
    "else:\n",
    "    print('gross.')\n",
    "                 \n",
    "print('thanks for playing.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Loops\n",
    "Loops allow you to run a bit of code multiple times. They're a great way to avoid copying and pasting the same bit of code multiple times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Loops can be written in multiple ways. \n",
    "\n",
    "The `for` loop iterates over the elements of the supplied list, and executes the containing block once for each element.\n",
    "\n",
    "Any kind of list can be used in the for loop (e.g., a list, a range, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you son of a bitch i'm in\n",
      "you son of a bitch i'm in\n",
      "you son of a bitch i'm in\n",
      "you son of a bitch i'm out\n"
     ]
    }
   ],
   "source": [
    "#for x in a_list:\n",
    "for x in range(3):\n",
    "    print('you son of a bitch i\\'m in')\n",
    "\n",
    "print('you son of a bitch i\\'m out')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\"><b>Task</b>: Write the Python code for <a href=\"https://i.redd.it/q9qc6bjzqr741.png\">this image\"</a> (also below; current code at the top is Java!).</div>\n",
    "\n",
    "![](https://i.redd.it/q9qc6bjzqr741.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can also use for loops to iterate over key-value pairs of a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parameter1 = 1.0\n",
      "parameter2 = 2.0\n",
      "parameter3 = 3.0\n"
     ]
    }
   ],
   "source": [
    "params = {\"parameter1\" : 1.0,\n",
    "          \"parameter2\" : 2.0,\n",
    "          \"parameter3\" : 3.0,}\n",
    "\n",
    "for key, value in params.items():\n",
    "    print(key + \" = \" + str(value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "_What will the above cell output?_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Sometimes it is useful to have access to the indices of the values when iterating over a list. We can use the `enumerate` function for this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 -3\n",
      "1 -2\n",
      "2 -1\n",
      "3 0\n",
      "4 1\n",
      "5 2\n"
     ]
    }
   ],
   "source": [
    "for idx, x in enumerate(range(-3,3)):\n",
    "    print(idx, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### List Comprehensions\n",
    "List comprehensions are a very compact way to create lists using a `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of values where x is squared for 0, 1, 2, 3, and 4.\n",
    "\n",
    "list_1 = [x**2 for x in range(0,5)]\n",
    "\n",
    "print(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### While loops\n",
    "The operator `while` lets you continue to run a loop as long as something is true. \n",
    "\n",
    "While loops always have the structure\n",
    "\n",
    "```\n",
    "while condition:\n",
    "    # Loop contents\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "still working\n",
      "still working\n",
      "still working\n",
      "still working\n",
      "still working\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "message = 'still working'\n",
    "counter = 0\n",
    "\n",
    "while counter < 5:\n",
    "    print(message)\n",
    "    \n",
    "    counter = counter + 1\n",
    "    \n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Continue operator\n",
    "<code>continue</code> is a special operator to jump ahead to the next iteration of a loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "lst = [0, 1, 2, 3]\n",
    "\n",
    "for item in lst:\n",
    "    \n",
    "    if item == 2:\n",
    "        continue\n",
    "    \n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Break operator\n",
    "`break` is a special operator to exit a loop. It's useful when you'd like to stop running a loop once you've hit a certain threshold or value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Establishing Connection...\n"
     ]
    }
   ],
   "source": [
    "connected = False\n",
    "\n",
    "while not connected:\n",
    "    \n",
    "    # Try and establish connection (placeholder code)\n",
    "    print('Establishing Connection...')\n",
    "    \n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](https://cdn1.iconfinder.com/data/icons/art-and-craft-3-flat/64/art-16-128.png)\n",
    "<div class=\"alert alert-success\"><b>Fibonnaci Sequence Task</b> Create a <b>for</b> loop that makes a list of Fibonacci numbers, up to 100. Remember that a Fibonnaci Sequence is where each value adds the previous two values: 1, 1, 2, 3, 5, etc.</div>\n",
    "\n",
    "**Hints**\n",
    "- Create an empty list by using empty brackets: `[]`\n",
    "- You can use the `break` function to decide when to stop your loop\n",
    "- Use the`append` function (see last lecture) to add values to your list.\n",
    "- You can use `while True` so that the function will run until it breaks.\n",
    "- You can assign two variables at the same time using the syntax `a,b = 0,1`\n",
    "\n",
    "Working with a team, pseudocode this on the whiteboard, _and then_ write it in the block below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Write your Fibonnaci sequence here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions\n",
    "\n",
    "If we have a useful chunk of code like the one you created for a Fibonacci sequence, we can save that as a function to easily recall later, using the keyword `def`. The syntax for functions is similar to loops and if statements:\n",
    "\n",
    "```def function():\n",
    "\tprint(value)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Fibonacci function\n",
    "\n",
    "def makeFibonacci():\n",
    "    # First, write docstring:\n",
    "    \"\"\"\n",
    "    This is a function that will take in a max value and create a Fibonacci sequence, starting at 0.\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"https://media2.giphy.com/media/kKLoC2AdoTftSgzR0O/source.gif\" alt=\"russiandollgif\" width=\"200\" height=\"200\">\n",
    "\n",
    "### Interrupting a kernel\n",
    "Writing loops is sometimes tricky, and one error in your code might leave you trapped in an infinite loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 1\n",
    "\n",
    "while a == 1:\n",
    "    print('AAAHHHH')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "_What happens if you get stuck in a forever loop and can't escape?_\n",
    "\n",
    "If there is a star next to the `In[ ]*:` at left, that means your cell is running. Similarly, if the circle next to Python3 is filled, the Kernel is busy.\n",
    "\n",
    "Use <b>Kernel > Interrupt</b> to stop the notebook. You can also use <b>Cell > Current Outputs > Clear</b> to clear your slate. \n",
    "\n",
    "It can be useful to clear and re-launch the kernel. You can do this from the 'kernel' drop down menu, at the top, optionally also clearing all ouputs. Note that this will erase any variables that are stored in memory. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resources\n",
    "\n",
    "<a href=\"https://swcarpentry.github.io/python-novice-plotting/17-conditionals/\">Software Carpentries Conditionals</a>\n",
    "\n",
    "<a href=\"https://merely-useful.github.io/py/py-dev-development.html\">Merely Useful Functions</a>\n",
    "\n",
    "<a href=\"https://github.com/jakevdp/WhirlwindTourOfPython/blob/6f1daf714fe52a8dde6a288674ba46a7feed8816/07-Control-Flow-Statements.ipynb\">Whirlwind Tour of Python: Control Flow</a> \n",
    "\n",
    "<a href=\"https://www.python-course.eu/python3_functions.php\">Python Course: Functions</a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# About this notebook\n",
    "This notebook is largely derived from UCSD COGS18 Materials, created by Tom Donoghue & Shannon Ellis, as well as the <a href=\"https://github.com/jakevdp/WhirlwindTourOfPython/blob/6f1daf714fe52a8dde6a288674ba46a7feed8816/07-Control-Flow-Statements.ipynb\">Control Flow Statements</a> notebook by J.R. Johansson.\n",
    "\n",
    "Want to run this notebook as a slideshow? If you have Python (or Anaconda) follow <a href=\"http://www.blog.pythonlibrary.org/2018/09/25/creating-presentations-with-jupyter-notebook/\">these instructions</a> to setup your computer with the RISE plugin."
   ]
  }
 ],
 "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"
  },
  "rise": {
   "theme": "serif"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}