06 Conditionals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Navigation Reminder\n",
    "\n",
    "- **Grey cells** are **code cells**. Click inside them and type to edit.\n",
    "- **Run**  code cells by pressing $ \\triangleright $  in the toolbar above, or press ``` shift + enter```.\n",
    "-  **Stop** a running process by clicking &#9634; in the toolbar above.\n",
    "- You can **add new cells** by clicking to the left of a cell and pressing ```A``` (for above), or ```B``` (for below). \n",
    "- **Delete cells** by pressing ```X```.\n",
    "- Run all code cells that import objects (such as the one below) to ensure that you can follow exercises and examples.\n",
    "- Feel free to edit and experiment - you will not corrupt the original files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 05: Conditionals and Comparisons\n",
    "\n",
    "The next lessons (05,06) are focused on the syntactical structures that make Python such a powerful tool for automation. In this lesson we will look at the conditional structures that help us program Python to make decisions.  In Lesson 06, we will look at loops as a way of programming repetitive tasks. \n",
    "\n",
    "Conditionals are statements that check True or False conditions to make decisions. \n",
    "\n",
    "In this lesson, we will learn to use **comparison operators** to craft conditional statements with **if**, **elif** and **else**.\n",
    "\n",
    "---\n",
    "Questions and exercises are distributed throughout this lesson. Please run the code cell below to import them before starting the lesson. The code will not produce any visible output, but exercises and questions will be loaded for later use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from QuestionsConditionals import E1, E2, E3, E4, E5, E6, E7, Q1, Q2, question, solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Lesson Goals:\n",
    "- Understand comparison operators\n",
    "- Distinguish between = (variable assignment) and == (equality comparison)\n",
    "- Understand membership operators & comparisons between text\n",
    "- Construct conditional statements with if, nested ifs, if-else and if-elif-else\n",
    "- Use try-except for error handling\n",
    "\n",
    "**Key Concepts:** if, elif, else, try, except, comparison operators, booleans, ==, in/not in, is/is not, nested ifs\n",
    "\n",
    "---\n",
    "# Comparison Operators\n",
    "\n",
    ">**Comparison operators** evaluate values without changing them.\n",
    "\n",
    "Statements with comparisons will return a **boolean value**, that is, a True or False value.\n",
    "\n",
    "Python's comparison operators are:\n",
    "\n",
    "| Operator | Meaning|\n",
    "| --- | ---|\n",
    "|**\\>** |greater than|\n",
    "|**\\>=**| greater than or equal to|\n",
    "|**==**| equal to **(!!)**|\n",
    "|**<** |less than|\n",
    "|**<=** |less than or equal to|\n",
    "|**!=** |not equal to|\n",
    "\n",
    "(If you have trouble with the greater than and less than signs, just remember that the wider side of the symbol points at the number that should be larger. You could think of it as the open mouth of an alligator, pointing at the larger prey.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### !!Remember!!\n",
    "\n",
    "- A single equals sign assigns values to a variable.\n",
    "\n",
    "- A double equals sign checks whether two items are equal.\n",
    "\n",
    "In the code below, let's assign value 1 to variable x:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's check whether variable x is equal to two. Obviously, it is not, as per the line above. The command line should return a value of False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x == 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 1:** In the code box below, define a variable named 'artist', with the text value 'Frida Kahlo'. Then create a conditional statement that checks whether the length of the string is greater than or equal to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution(E1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Strings and Comparisons\n",
    "\n",
    "Comparison operators also work with text data (strings), because strings are sequences of characters. \n",
    "\n",
    "**```==```** and **```!=```** return True and False respectively if two strings match exactly. \n",
    "\n",
    "Other operators will compare the strings based on character order in the [AASCII character set](http://www.asciitable.com). In this set, all capitalized letters precede all lowercase letters. So, if you are trying to order strings alphabetically, the comparisons might output unexpected results.\n",
    "\n",
    "This fact can be important with string comparisons. Take three variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "frida= 'frida kahlo'\n",
    "Frida= 'Frida Kahlo'\n",
    "diego= 'diego rivera'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to compare them, the comparison operator will look at the objects according to the order of their characters in the character set. Starting at the first character, it will compare each sequentially. If we compare lowercase frida and diego, it suggests that d is smaller than f, as we would expect with alphabetical order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diego<frida"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But if Frida is capitalized, it will evaluate the same condition as false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diego<Frida"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This surprising result is a consequence of the ASCII character order, where all capital letters precede all lowercase ones. It is something to take into account when performing string comparisons. \n",
    "\n",
    "---\n",
    "## Boolean Operators\n",
    "\n",
    "Simple statements including comparisons can be combined to create complex conditions.\n",
    "\n",
    "**Boolean operators** allow us to evaluate more than one comparison simultaneously or modify a comparison. \n",
    "\n",
    "These include:\n",
    "\n",
    "|Operator| For True value:|\n",
    "| --- | ---|\n",
    "|**and** |Two conditions must be simultaneously true|\n",
    "|**or** |One or another condition must be true|\n",
    "|**not** |Negate a condition|\n",
    "\n",
    "\n",
    "As you might remember, we already created a variable x with value 1 (if not, you can always call it by writing its name, or print it with the print() function to check!). \n",
    "\n",
    "Let's use boolean operators to test multiple conditions on x.\n",
    "\n",
    "Using **and**, we can check whether two conditions are **both** true. In our case, x **is** equal to 1, but is not greater than 2, so the condition below should be false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == 1 and x > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With **or**, we can check whether any one condition of several is true. In our case, because x is equal to 1, the below cell should output True, even though the second condition is not fulfilled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == 1 or x > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, with **not**, we can negate a condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not x > 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When combined with other conditions, it will still require the and/or keywords:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x==1 and not x>2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have more than two conditions, it can be useful to use **parentheses** **```()```** for clarity or to force a specific order of evaluation, as was possible with numerical operations. Note that the two conditonal statements below are conceptually different, and will lead to different results depending on the value of x:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x==1 and x<5) or x>2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x==1 and (x<5 or x>2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, the parentheses group two conditions to be negated, whereas in the subsequent cell, it delimits the negation to only one condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not (x<5 or x>2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(not x<5) or x>2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2** Earlier on in the lesson, we created the variable 'artist'. In the empty cell below, Create a conditional statement that tests whether the length of the string is both greater than or equal to 10 and less than 15. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you write the conditional statement correctly, the cell's output should be ```True```. Because the string 'Frida Kahlo' has 11 characters (including whitespace), it is larger than or equal to 10 and less than 15 characters long."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution(E2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Membership Operators\n",
    "\n",
    ">**Membership operators** test whether an item is in a sequence, such as a string, list or other compound data structure. \n",
    "\n",
    "**in/not in**: Check whether a value exists in a sequence (or not), giving True/False respectively.\n",
    "\n",
    "This can be used to test whether an item is in a list, or a substring is in a string.\n",
    "\n",
    "**Exercise 3:** Let's go back to our variable 'artist'. Using the code cell below, write a statement that checks whether the string Frida is part of the string that was assigned to our artist variable.\n",
    "\n",
    "The expected output is ```True```. Remember to always surround strings with quotes, and that the command is case sensitive. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution(E3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 4** In the code cell below, use 'not in' to evaluate whether 'Pablo Picasso' is not in the list below. The output value should be ```True```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "artists = ['Frida Kahlo', 'Andy Warhol', 'Remedios Varo']\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution(E4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# The if statement\n",
    "\n",
    "The if statement is a line of code that asks Python to check a condition, and run a code block if the condition is true.\n",
    "\n",
    "```python\n",
    "    if <condition>:\n",
    "    code to run when condition is True\n",
    "```\n",
    "\n",
    "It is formed by the reserved word **if** followed by our condition and a colon. Indented, new lines form part of the code block that will only run if the condition is true. If the conditions is false, they will be skipped.\n",
    "\n",
    "<img src=\"Other_files/if.jpeg\" width=\"200\" >\n",
    "\n",
    "Let's create a new variable x, assigning it a value of zero. The code below prints an output when the condition is True. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This condition is True, and should thus output the text\n",
    "x = 0\n",
    "\n",
    "if x < 2:  #Conditional statement that is True\n",
    "    print('x is smaller than 2') #Indented block indicating action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the other hand, when the condition is false, the code does not run, so we have no output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This condition is False, and should not output anything.\n",
    "x = 3\n",
    "\n",
    "if x<2: # Conditional statement that is False\n",
    "    print('x is smaller than 2') #Indented block indicating action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 5:** Use an 'if' statement to print the artist name and the string length if the length of the string is greater than or equal to 10. Format the output as 'Frida Kahlo: 11 letters'.\n",
    "\n",
    "For this exercise, you will need to use the str(), print() and len() functions, as well as string concatenation with +."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution(E5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Either/or: If-else\n",
    "\n",
    "The  if statement that we just discussed will get code to run only if a certain condition is met. But how do we ask the program to do one thing if a condition is True, and another if it is False?\n",
    "\n",
    "**else** is another reserved word that allows us to construct an alternative to an if statement. Following an if block, an else block provides the action to perform if the condition was not fulfilled.\n",
    "\n",
    "```python\n",
    "if condition :\n",
    "    code A runs when condition is True\n",
    "else : \n",
    "    code B runs when condition is False\n",
    "```\n",
    "\n",
    "The else statement starts at the same indentation level as the if statement. That is, you have to exit the previous code block by de-indenting. The reserved word 'else' is followed by a semicolon and a new indented block with code.\n",
    "\n",
    "<img src=\"Other_files/ifelse.jpeg\" width=\"200\" >\n",
    "\n",
    "The else statement is optional. When omitted, a False condition will yield no output, as we saw before.\n",
    "\n",
    "In the example below, we assign value 1 to the variable x, and print 'x is less than 0' if the condition is true, and 'x is greater than 0' if the condition is false. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "\n",
    "if x < 0:\n",
    "    print('x is less than 0')\n",
    "else:\n",
    "    print('x is greater than 0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "question(Q1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi-way branching: If-elif-else:\n",
    "\n",
    "```elif``` is another reserved word in Python that allows us to add multiple branches to an if statement. \n",
    "\n",
    "It can be added after an ```if``` and before an (optional) ```else``` clause.\n",
    "\n",
    "```python\n",
    "if condition1 :\n",
    "    code A runs when condition1 is True\n",
    "elif condition2 :\n",
    "    code B runs when condition1 is False and condition2 is True\n",
    "else:\n",
    "    code C runs when condition1 and condition2 are False\n",
    "```\n",
    "\n",
    "<img src=\"Other_files/ifelifelse.jpeg\" width=\"300\" >\n",
    "\n",
    "In the following example, we include one ```elif``` clause, but we can use multiple ```elif``` statements. We set a value for variable x. And then, if x is less than zero, we print 'x is less than 0'. Otherwise, if x is less than 5, the code prints 'x is less than 5'. Finally if neither condition is true, the code will run the ```else``` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "\n",
    "if x < 0:\n",
    "    print('x is less than 0')\n",
    "elif x < 5:\n",
    "    print('x is less than 5')\n",
    "else:\n",
    "    print('x is greater than 5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using elif, **the order of conditions matters.**\n",
    "\n",
    "If condition 1 is evaluated as True, condition 2 will not be checked. \n",
    "\n",
    "This could lead to unexpected program choices if your ```if```, ```elif``` and ```else``` statements have not been designed carefully. \n",
    "\n",
    "For instance, in the example below, the ```elif``` statement will never be tested. Whatever the value of x, we will never get the message \"x is less than 0\".\n",
    "\n",
    "Any values that are less than 0 are also less than 5. That means that for values less than zero, the first condition will be evaluated as True, and the second condition will never run. Thus, we will never get the output \"x is less than 0\". Even for x = -1, we will get \"x is less than 5\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -1 #Let's give x a new value of -1\n",
    "\n",
    "if x < 5:\n",
    "    print(\"x is less than 5\")\n",
    "elif x < 0:\n",
    "    print(\"x is less than 0\")\n",
    "else:\n",
    "    print(\"x is greater than or equal to 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 6:** Copy and paste the code above in the empty cell below. Reorder the conditions so that it will output the proper message, i.e. \"x is less than 0\". \n",
    "\n",
    "Test it with different values of x to make sure the code is working properly for all values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution(E6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 7:** Using the code you just constructed, add another block that checks whether the value of x is greater than or equal to 10. Be careful with the order of conditions, and test your code on different values of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution(E7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# If-And: Nested ifs\n",
    "\n",
    "In lesson 02, we saw that code blocks can be **nested** by increasing indentation. This means that one code block will run within another.\n",
    "\n",
    "Nesting if statements will result in two conditions that need to be satisfied for the innermost code to run. \n",
    "\n",
    "For instance:\n",
    "\n",
    "```python\n",
    "if <condition1>:\n",
    "    code A runs if condition 1 is True\n",
    "    if <condition 2>\n",
    "        code B runs if condition 1 and condition 2 are True\n",
    "```\n",
    "\n",
    "<img src=\"Other_files/nestedif.jpeg\" width=\"300\" >\n",
    "\n",
    "In the example below, we assign the value -1 to the variable x and check a series of nested conditions. Using a nested if allows us to evaluate a second condition only when the first  condition is True. You can play with the value of x to see how the results change. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=-1\n",
    "\n",
    "if x<5:\n",
    "    print(\"x is less than 5\")\n",
    "    if x<0:\n",
    "        print(\"x is also less than 0\")\n",
    "else:\n",
    "    print(\"x is more than or equal to 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "question(Q2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In short, if, elif and else and nested ifs can be used and combined to create complex conditional structures within which programs make decisions. Their use requires careful thought about potential outputs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# Lesson Summary\n",
    "\n",
    "- Comparison operators evaluate statements that juxtapose two variables or values by giving a True or False value\n",
    "- == (double equals sign) is the operator for testing for equality, because = (single equals sign) is already used for assigning variables\n",
    "- Strings are compared by alphabetical order, based on your computer's character set. \n",
    "- Membership operators in-not in and is-is not test whether a value is in a set.\n",
    "- The if statement creates a code that is run conditionally if a comparison returns True\n",
    "- The else statement provides an alternative, if the comparison returns False\n",
    "- Elif and nesting ifs allow us to insert additional conditions, replicating OR or AND statements.\n",
    "\n",
    "<div style=\"text-align:center\">    \n",
    "  <a href=\"05%20Basic%20Data%20Types%20III%20-%20Collections.ipynb\">Previous Lesson: Basic Data Types III - Collections</a>|\n",
    "   <a href=\"07%20Loops.ipynb\">Next Lesson: Loops</a>\n",
    "</div>"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}