Lab-Lesson.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab Lesson\r\n",
    "\r\n",
    "## Introduction to Python, Part 1\r\n",
    "\r\n",
    "\r\n",
    "**Topics:**\r\n",
    "\r\n",
    "* Values and Types\r\n",
    "* Variables\r\n",
    "* Operators\r\n",
    "* User Input\r\n",
    "* Changing Data Types\r\n",
    "* Exception Handling\r\n",
    "* Control Flow\r\n",
    "\r\n",
    "For a more in-depth discussion of these topics, read chapters 2 & 3 of *Python for Everybody*.\r\n",
    "* [Click here to read Chapter 2 - Variables](https://www.py4e.com/html3/02-variables)\r\n",
    "* [Click here to read Chapter 3 - Conditionals](https://www.py4e.com/html3/03-conditional)\r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Python for Everybody*\n",
    "\n",
    "*Python for Everybody* is a free online textbook published under the Creative Commons Licence that is a great starter and reference guide for python.  Most of the lab excersises will be based on sections of *Python for Everybody* - in fact, its a great starting reference and could contain hints to solving every excersise, should you get stuck.  It breaks down the basics of python and programming as a whole, as many of the concepts we'll cover talking about python apply to almost every programming language.  The book itself is availible for purchase if you're *really* interested in a print copy, but it available as a PDF and epub from the writer for free [here](https://www.py4e.com/book.php).  Some sections of *Python for Everybody* have been adapted from another book, *How to think like a Computer Scientist: Learning with Python* by Allen Downey, Jeff Elkner and Chris Meyers.  This book is also available for free online [here](https://greenteapress.com/wp/learning-with-python/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Values and Types\n",
    "\n",
    "* A *value* is one of the basic things a program works with, like a letter or a number.\n",
    "* Values are the nouns of Python programs.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Values have a *type*\n",
    "* The first step in understanding Python programming is understanding the different types.\n",
    "* We can use the `type()` function to ask Python to tell what type something is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* So what is Python telling us about the value `4`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type: Integers\n",
    "\n",
    "* Python has a type, called `int`, that is used for representing integer numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# regular numbers are ints\n",
    "print(4) \n",
    "print(type(4))\n",
    "\n",
    "# negative numbers are ints\n",
    "print(-1) \n",
    "print(type(-1))\n",
    "\n",
    "# Even big numbers are ints\n",
    "print(20928375403298570293847503984570938457)\n",
    "print(type(20928375403298570293847503984570938457))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Be careful when writing big numbers, you can't write them in the way humans write them!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1,000,000, sep=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# European style\n",
    "print(1.000.000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The computer is *very* *very* specific about how things are written.\n",
    "* Get used to lots of error messages.\n",
    "* Pay attention to every word and every character you type!\n",
    "* Like learning to see the Matrix."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type: Floating Point numbers\n",
    "\n",
    "* But what about non-integer numbers?\n",
    "* What would be a non-integer number?\n",
    "* Python has a type, called `float`, that is used for representing fractional numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(3/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(0.75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(3.1419764565468465465465465465165468484684)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type: Strings\n",
    "\n",
    "* Even though everything is a number in the computer world...\n",
    "* The purpose of Python is to make the computer world more *humane*.\n",
    "* Often we need to deal with textual data so we use the *string* type!\n",
    "* The syntax for strings is double (\") or single (') quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"hello world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(hello world)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type('Hello World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Note: You can't mix and match quotes!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Most people use double quotes because then they don't have apostrophe issues."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('I can','t even!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"I can't even, \\n either!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type: Boolean\n",
    "\n",
    "* Python has a data type for True and False\n",
    "* A boolean is either `True` or `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Literal true data type, notice how it turns green\n",
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# checking the type of True\n",
    "type(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Literal false data type, notice how it turns green\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# checking the data type of False\n",
    "type(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "* A variable is a name that refers to a value, so we don't have to literally type the value all the time. \n",
    "* We *assign* different types of data to variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"Hello, what a wonderful Thursday morning.\"\n",
    "number = 3\n",
    "pi = 3.1415926535897931"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* This code creates three variables and assigns them different data types.\n",
    "* The `type` of a variable depends upon the value it refers to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Names and Python Keywords\n",
    "\n",
    "* There are rules and conventions for naming variables in Python.\n",
    "* Rules:\n",
    "    * Variable names cannot begin with numbers.\n",
    "    * Variable names cannot contain spaces.\n",
    "    * Variable names are case sensitive.\n",
    "    * Variable names cannot be one of the Python *keywords*\n",
    "\n",
    "```\n",
    "and       del       from      None      True\n",
    "as        elif      global    nonlocal  try\n",
    "assert    else      if        not       while\n",
    "break     except    import    or        with\n",
    "class     False     in        pass      yield\n",
    "continue  finally   is        raise\n",
    "def       for       lambda    return\n",
    "```\n",
    "\n",
    "* Conventions:\n",
    "    * Don't start variables with capital letters.\n",
    "    * Use underscores instead of spaces.\n",
    "    * Use descriptive variable names.\n",
    "    * Read [PEP 8 -- Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/)\n",
    "    \n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# don't use keywords for variable names\n",
    "and = \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# long names are good for reading, but are long\n",
    "this_is_a_good_variable_name = 4\n",
    "print(this_is_a_good_variable_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# don't use spaces!\n",
    "Hello number for = 4\n",
    "print(Where are you @)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# don't get too funky with weird characters\n",
    "what@isup? = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clown = \"🤡\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(clown)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators\n",
    "\n",
    "* The Python programming language could be treated as a very fancy or complicated calculator.\n",
    "* All of the mathematical operators you know and love are available in Python\n",
    "    * Addition: `+`\n",
    "    * Subtraction: `-`\n",
    "    * Multiplication: `*`\n",
    "    * Division: `/`\n",
    "    * Modulus: `%`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# addition\n",
    "5 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# subraction\n",
    "5 - 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Works with variables\n",
    "a = 5\n",
    "b = ((3 + a) - 235345)\n",
    "\n",
    "a * b // 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modulus is for calculating the remainder\n",
    "remainder = 5 % 3\n",
    "print(remainder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Operators\n",
    "\n",
    "* You can use these mathematical operators on string types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make strings instead of numbers\n",
    "a = 'School of Computing'\n",
    "b = 'and Information'\n",
    "\n",
    "a + \" \" + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Mixing up datatypes is a common bug in your code. \n",
    "* Sometimes Python will figure out what you were trying to do...\n",
    "* Other times it won't"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = str(5)\n",
    "b = '3'\n",
    "\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User Input\n",
    "\n",
    "* If you want the user (you) to give your program information, you can use the `input()` function.\n",
    "* Input will display a text entry box when you run the cell and save it to a variable (if you assign a variable to the input function).\n",
    "* Put a string inside the function to create a prompt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# as for the user's name and put it in a variable called name\n",
    "name = input(\"What is your name?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now print the contents of the variable called name\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing Data Types\n",
    "\n",
    "* If you want to do mathematical operations on your data, make sure your data is of the right type\n",
    "* You can't add a string to an integer.\n",
    "* You can't divide a float by a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What will happen when we run this?\n",
    "\"5\" + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Use the `int()` function to transform a string into a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# store a number as a string\n",
    "number = \"5\"\n",
    "print(type(number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transform number from a string to an int\n",
    "number = int(number)\n",
    "print(type(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Use the `str()` function to *coerce* your data into a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transform a number into a string representation\n",
    "number = 5\n",
    "print(type(number))\n",
    "\n",
    "number = str(number)\n",
    "print(type(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Use the `float()` function to transform decimal numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transform a number into a string representation\n",
    "number = \"5.5\"\n",
    "print(type(number))\n",
    "\n",
    "number = float(number)\n",
    "print(type(number))\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The `input()` function always gives you data of type string\n",
    "* If the data you are getting is a number, you got to transform it\n",
    "* Make sure to transform to the right data type! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try converting a string containing a decimal to an integer\n",
    "number = input(\"Input a decimal number:\")\n",
    "print(type(number))\n",
    "number = int(number)\n",
    "print(type(number))\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert a decimal to a float\n",
    "number = input(\"Input a decimal number:\")\n",
    "print(type(number))\n",
    "number = float(number)\n",
    "print(type(number))\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow\n",
    "\n",
    "* We can use *logical operators* (<, >, !=, is, is not) and *conditional expressions* (if, else, elif) *control the flow of execution*\n",
    "* if true then do this, else do that\n",
    "* We use *boolean expressions* (True, False) to answer Yes/No questions and decide which path to execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# testing for equality\n",
    "5 == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Does five equal six?\n",
    "5 == 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6 != 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Note the double equals sign, if we had one equals we would be a variable assignment.\n",
    "* `==` is called a *comparison operators* and there are many others\n",
    "```python\n",
    "x != y               # x is not equal to y\n",
    "x > y                # x is greater than y\n",
    "x < y                # x is less than y\n",
    "x >= y               # x is greater than or equal to y\n",
    "x <= y               # x is less than or equal to y\n",
    "x is y               # x is the same as y\n",
    "x is not y           # x is not the same as y\n",
    "```\n",
    "* These allow you to express logical operations in your programs.\n",
    "\n",
    "```python\n",
    "x > 0 and x < 10\n",
    "```\n",
    "\n",
    "* This expression is true only when \"the variable x is greater than zero AND less than 10\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the variable x is greater than zero AND less than 10\n",
    "x = 5\n",
    "x > 0 and x < 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the variable x is greater than zero AND less than 10\n",
    "x = 50\n",
    "x > 0 and x < 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the variable x is greater than zero AND less than 10\n",
    "x = 50\n",
    "x > 0 or x < 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional execution\n",
    "\n",
    "* use the `if`, `else`, and `elif` statements to steer the direction of your program "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test to see if x is positive and print if it is\n",
    "x = 5\n",
    "if x > 0:\n",
    "    print(\"x is a positive number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test to see if x is positive and print if it is\n",
    "x = -5\n",
    "if x > 0:\n",
    "    print(\"x is a positive number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Notice, nothing printed because the condition, `x > 5` was false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 5 == 5:\n",
    "    print(\"yup\")\n",
    "    print(\"Yup, five is five\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 5 == 6:\n",
    "    print(\"five is six, huh?\")\n",
    "    print(\"this won't run\")\n",
    "    \n",
    "# This line executes no matter what\n",
    "print(\"I am done.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* use `!=` to say \"not equals\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# testing not equality\n",
    "if 5 != 6:\n",
    "    print(\"five is six, huh?\")\n",
    "    print(\"this won't run\")\n",
    "\n",
    "# This line executes no matter what\n",
    "print(\"I am done.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* No print because 5 doesn't equal 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 5 > 6:\n",
    "    print(\"five is greater than six, what?\")\n",
    "    print(\"hi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Works with variables too!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 6\n",
    "\n",
    "if x < y:\n",
    "    print(x, \"is less than\", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alternative execution\n",
    "\n",
    "* if true do this, else do that "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check to see if x is even or odd\n",
    "x = 20\n",
    "if (x % 2) == 0: # using the modulo operator\n",
    "    print(\"x is even\")\n",
    "else:\n",
    "    print(\"x is odd\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check to see if x is even or odd\n",
    "x = 21\n",
    "if (x % 2) == 0: # using the modulo operator\n",
    "    print(\"x is even\")\n",
    "else:\n",
    "    print(\"x is odd\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check to see if x is even or odd\n",
    "x = 0\n",
    "if (x % 2) == 0: # using the modulo operator\n",
    "    print(\"x is even\")\n",
    "else:\n",
    "    print(\"x is odd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested Conditionals\n",
    "\n",
    "* You can put conditional statements inside of other conditional statements\n",
    "* This lets you compose more complex logic in your programs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 5\n",
    "\n",
    "if x == y:\n",
    "    print('x and y are equal')\n",
    "else:\n",
    "    if x < y:\n",
    "        print('x is less than y')\n",
    "    else:\n",
    "        print('x is greater than y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 50\n",
    "y = 5\n",
    "\n",
    "if x == y:\n",
    "    print('x and y are equal')\n",
    "else:\n",
    "    if x < y:\n",
    "        print('x is less than y')\n",
    "    else:\n",
    "        print('x is greater than y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 50\n",
    "\n",
    "if x == y:\n",
    "    print('x and y are equal')\n",
    "else:\n",
    "    if x < y:\n",
    "        print('x is less than y')\n",
    "    else:\n",
    "        print('x is greater than y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chained Conditionals\n",
    "\n",
    "* If there are more than two conditions you want to check use `elif` (else if)\n",
    "* Use there if there are more than two branches in your logic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiple conditions\n",
    "\n",
    "\n",
    "age = int(input(\"Give me your age\"))\n",
    "\n",
    "if 0 < age < 1:\n",
    "    print(\"baby\")\n",
    "elif 1 <= age <= 3:\n",
    "    print(\"toddler\")\n",
    "elif 3 <= age <= 9:\n",
    "    print(\"kid\")\n",
    "elif 10 <= age <= 12:\n",
    "    print(\"Tween\")\n",
    "elif 13 <= age <= 17:\n",
    "    print(\"Teen\")\n",
    "elif 18 <= age < 120:\n",
    "    print(\"Adult, welcome to misery.\")\n",
    "else:\n",
    "    print(\"No one can live that long!\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exception Handling\n",
    "\n",
    "* Sometimes you have a decimal number and you want to do something integer-y or you have a number as a string and not an int or float datatype\n",
    "* If you try and do an operation on the data you will get an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python won't like this\n",
    "string_decimal_number = \"5.5\"\n",
    "int(string_decimal_number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# but this will work\n",
    "string_decimal_number = \"5.5\"\n",
    "float(string_decimal_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the `try/except` statements to \"catch\" your error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prompt the user for a number\n",
    "number = input(\"Input a number:\")\n",
    "try:\n",
    "    int_number = int(number)\n",
    "    print(\"I am an integer number\")\n",
    "except:\n",
    "    float_number = float(number)\n",
    "    print(\"I am a floating point number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at that code above again.\n",
    "\n",
    "What `try` does is say to Python: \"This code might cause an error and say something's wrong. I know that, so let me handle it.\" If an error *does* happen inside a `try` block, it'll jump to `except` and start running that code.\n",
    "\n",
    "So, above, when you input a number, it'll *try* to convert it into an integer. But, not all numbers are integers. If Python gets an error, it doesn't freak out and crash. It just jumps to the `except` block. \n",
    "\n",
    "Run that code block above again. Enter integers and non-integers. How can you still break it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Putting it all together\n",
    "\n",
    "The code cell below contains the code for a whole program that combines all of the topics we learned about. Try running it a few times and see what happens!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the age and animal type from the user\n",
    "age = input(\"Input Age:\")\n",
    "kind = input(\"Cat, Dog, Human\")\n",
    "\n",
    "# make age into an number\n",
    "try:\n",
    "    age = int(age)\n",
    "except:\n",
    "    age = float(age)\n",
    "\n",
    "if kind == \"Human\" or kind == \"human\": # check for caps\n",
    "    if 0 < age < 1:\n",
    "        print(\"baby\")\n",
    "    elif 1 <= age <= 3:\n",
    "        print(\"toddler\")\n",
    "    elif 3 <= age <= 9:\n",
    "        print(\"kid\")\n",
    "    elif 10 <= age <= 12:\n",
    "        print(\"Tween\")\n",
    "    elif 13 <= age <= 17:\n",
    "        print(\"Teen\")\n",
    "    elif 18 <= age <120:\n",
    "        print(\"Adult, welcome to misery.\")\n",
    "    else:\n",
    "        print(\"No one can live that long!\")\n",
    "        \n",
    "elif kind == \"Dog\" or kind == \"dog\": \n",
    "    if 0 < age <= 1:\n",
    "        print(\"Puppy\")\n",
    "        print(age * 7, \"human years.\")\n",
    "    else:\n",
    "        print(\"Adult\")\n",
    "        print(age * 7, \"human years.\")\n",
    "\n",
    "elif kind == \"Cat\" or kind == \"cat\":\n",
    "    if 0 <= age <= 1:\n",
    "        print(\"Innocent Kitten\")\n",
    "        print(\"???\", \"human years.\")\n",
    "    else:\n",
    "        print(\"Evil Beast\")\n",
    "        print(\"???\", \"human years.\")\n",
    "else:\n",
    "    print(\"I don't know that animal.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![We are done, bye yall](https://media3.giphy.com/media/3oriNUhXRrpZOXWBt6/giphy.gif)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}