Lesson 3. Booleans, If Statements and While Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far we've seen that Python can do calculations with variables such as $x + y$, $x \\times y$, etc. Python can also check if certain relations between variables are true. For example, it can check if $x > y$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "print(x > y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can also check if $x < y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(x < y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if $x \\geq y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(x >= y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if $x \\leq y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(x <= y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if $x = y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(x == y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or if $x \\neq y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(x != y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "True and False are a data type called booleans. We can assign a boolean to a variable just like other data types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "var1 = True\n",
    "var2 = 1 > 2\n",
    "\n",
    "print(var1)\n",
    "print(var2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print('dog' == 'cat')\n",
    "print('dog' != 'cat')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use $>$ and $<$ with strings to check which string goes first in alphabetical order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print('dog' > 'cat') #\"dog\" comes after \"cat\" in alphabetical order, so this is True\n",
    "print('bird' < 'fish') #\"bird\" comes before \"fish\" in alphabetical order, so this is True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that Python considers capital letters to come before lowercase letters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('A' < 'a')\n",
    "print('Z' > 'a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that numbers and strings are treated differently!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(10 > 5)\n",
    "print(str(10) > str(5))\n",
    "print(10 == '10')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings and numbers cannot be directly compared:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unorderable types: str() > int()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-21-736064c1ed1f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'2'\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unorderable types: str() > int()"
     ]
    }
   ],
   "source": [
    "print('2' > 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make more complicated *boolean expressions* using the keywords \"and\" and \"or\". $x$ and $y$ is True if and only if both $x$ and $y$ are True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True and True)\n",
    "print(True and False)\n",
    "print(False and True)\n",
    "print(False and False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(1 == 1 and 4 == 2 * 2)\n",
    "print('dog' == 'dog' and 'dog' == 'cat')\n",
    "print(3 >= 6 and 10 < 11)\n",
    "print('a' > 'b' and 5 == '5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$x$ or $y$ is True if either $x$ or $y$ are True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True or True)\n",
    "print(True or False)\n",
    "print(False or True)\n",
    "print(False or False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(1 == 1 or 4 == 2 * 2)\n",
    "print('dog' == 'dog' or 'dog' == 'cat')\n",
    "print(3 >= 6 or 10 < 11)\n",
    "print('a' > 'b' or 5 == '5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use the \"not\" keyword to swap between True and False:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "y = 10 > 100\n",
    "\n",
    "print(not x)\n",
    "print(not y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to determine if each boolean expression is True or False. Then use Python to check your work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "12 >= 5 and 7 != 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'rabbit' > 'carrot' or not 'frog' == 'toad'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "120 > 12 and 'apple' < 'orange' and int('123') < 321"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# If Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Booleans allow us to do something that we couldn't before: They allow us to write code that will do different things depending on what the values of our variables are. We can do this with *if statements*. For example, we could ask a user what their name is, and print a special message if they have a certain name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type in your name: Luigi\n",
      "Hello, Luigi!\n",
      "Hey, that's my name, too!\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Type in your name: \")\n",
    "print(\"Hello, \", name, '!', sep='')\n",
    "\n",
    "if name == 'Luigi':\n",
    "    print(\"Hey, that's my name, too!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could also choose to print a different message if they don't have the name we're looking for:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type in your name: Peach\n",
      "Hello, Peach!\n",
      "That's a cool name!\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Type in your name: \")\n",
    "print(\"Hello, \", name, '!', sep='')\n",
    "\n",
    "if name == 'Luigi':\n",
    "    print(\"Hey, that's my name, too!\")\n",
    "    \n",
    "else:\n",
    "    print(\"That's a cool name!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create custom messages for several different names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type in your name: Mario\n",
      "Hello, Mario!\n",
      "Hey, that's my brother's name!\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Type in your name: \")\n",
    "print(\"Hello, \", name, '!', sep='')\n",
    "if name == 'Luigi':\n",
    "    print(\"Hey, that's my name, too!\")\n",
    "    \n",
    "elif name == 'Mario':\n",
    "    print(\"Hey, that's my brother's name!\")\n",
    "    \n",
    "elif name == 'Bowser':\n",
    "    print(\"Mamma mia! I don't like that name!\")\n",
    "\n",
    "else:\n",
    "    print(\"That's a cool name!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n",
    "1\\. Write a Python script that asks the user to enter a number. If the number is positive, print \"Your number is positive!\" If the number is negative, print \"Your number is negative!\" If the number is 0, print \"Your number is 0!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2\\. Write a function that takes two arguments, $x$ and $y$ and returns $x$ if $y = 0$ and returns $x \\div y$ if $y \\neq 0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# While Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use booleans to keep running code as long as a condition is True using a *while loop*. For example, this code will print all the integers from $1$ to $10$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "num = 1\n",
    "while num <= 5:\n",
    "    print(num)\n",
    "    num = num + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you run a while loop, Python checks if your boolean expression is true. If it is, it runs everything in the body of the while loop, and then it checks if your boolean expression is still true. If it is true, it runs the body of the while loop again and again until it becomes false. Once the boolean expression is false, the while loop ends.\n",
    "\n",
    "You use while loops to keep a running total of a variable. For example, this code prints the sum of all the integers from 1 to 5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "answer = 0\n",
    "num = 1\n",
    "while num <= 5:\n",
    "    answer = answer + num\n",
    "    num = num + 1\n",
    "    \n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can combine if statements and while loops to check that your user is giving you correct input. For example, let's say you want the user to choose one of the following meals for dinner: chicken, fish, or beef:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You can select one of the following meals for dinner: chicken, fish, or beef.\n",
      "What is your selection? lamb\n",
      "Sorry, that was not an option.\n",
      "What is your selection? turkey\n",
      "Sorry, that was not an option.\n",
      "What is your selection? beef\n",
      "OK, you selected beef.\n",
      "Thank you for making your selection!\n"
     ]
    }
   ],
   "source": [
    "print(\"You can select one of the following meals for dinner: chicken, fish, or beef.\")\n",
    "\n",
    "made_selection = False\n",
    "\n",
    "while not made_selection:\n",
    "    selection = input(\"What is your selection? \")\n",
    "\n",
    "    if selection == 'chicken':\n",
    "        print(\"OK, you selected chicken.\")\n",
    "        made_selection = True\n",
    "\n",
    "    elif selection == 'fish':\n",
    "        print(\"OK, you selected fish.\")\n",
    "        made_selection = True\n",
    "\n",
    "    elif selection == 'beef':\n",
    "        print(\"OK, you selected beef.\")\n",
    "        made_selection = True\n",
    "\n",
    "    else:\n",
    "        print(\"Sorry, that was not an option.\")\n",
    "\n",
    "print(\"Thank you for making your selection!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "1\\. Use a while loop to find the sum of the square roots of all the numbers from 1 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2\\. Use Python to create a rock, paper, scissors game. The game should take inputs from two players and tell which player one. For example, if player 1 enters \"rock\" and player 2 enters \"scissors\", the computer should say \"Player 1 wins!\". You are free to add additional rules and features, and you can be as creative as you want with this game. For example, you could keep score of how many times each player wins, or you could add more options such as \"dynamite\". \n",
    "\n",
    "Here is some code to get you started:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Let's play Rock, Paper, Scissors!\n",
      "Player 1, make your choice: rock\n",
      "Player 2, make your choice: paper\n",
      "Player 2 wins!\n"
     ]
    }
   ],
   "source": [
    "print(\"Let's play Rock, Paper, Scissors!\")\n",
    "\n",
    "player1_chose = False\n",
    "\n",
    "while not player1_chose:\n",
    "    player1 = input(\"Player 1, make your choice: \")\n",
    "    \n",
    "    if player1 == 'rock' or player1 == 'paper' or player1 == 'scissors':\n",
    "        player1_chose = True\n",
    "        \n",
    "    else:\n",
    "        print(\"That is not a valid choice. Choose again.\")\n",
    "    \n",
    "player2_chose = False\n",
    "\n",
    "while not player2_chose:\n",
    "    player2 = input(\"Player 2, make your choice: \")\n",
    "    \n",
    "    if player2 == 'rock' or player2 == 'paper' or player2 == 'scissors':\n",
    "        player2_chose = True\n",
    "        \n",
    "    else:\n",
    "        print(\"That is not a valid choice. Choose again.\")\n",
    "        \n",
    "if player1 == 'rock' and player2 == 'scissors':\n",
    "    print(\"Player 1 wins!\")\n",
    "    \n",
    "elif player1 == 'rock' and player2 == 'paper':\n",
    "    print(\"Player 2 wins!\")\n",
    "    \n",
    "elif player1 == 'paper' and player2 == 'rock':\n",
    "    print(\"Player 1 wins!\")\n",
    "    \n",
    "elif player1 == 'paper' and player2 == 'scissors':\n",
    "    print(\"Player 2 wins!\")\n",
    "    \n",
    "elif player1 == 'scissors' and player2 == 'rock':\n",
    "    print(\"Player 2 wins!\")\n",
    "    \n",
    "elif player1 == 'scissors' and player2 == 'paper':\n",
    "    print(\"Player 1 wins!\")\n",
    "    \n",
    "elif player1 == player2:\n",
    "    print(\"It's a tie!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}