HCC_Day1_Part1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#4857E2'><h1>HER CODE CAMP Intro to Python - Day 1 - The Basics</h1></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to the Intro to Python coding workshop! We are going to learn all kinds of coding fundamentals, and along the way, we will learn code to put together a game of rock-paper-scissors! Code along with us in this notebook. When you're ready to run what's in your code block, hit <code><font color='#33a1fd'>ctrl+enter</font></code>!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#357DED'><h2>Section 1: SYNTAX</h2></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many programmers start coding with a basic <b>\"Hello World!\"</b> program. The goal of this program is to print the message \"Hello World!\" on the screen. Let's run your first program in Python!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run \"Hello World\" program\n",
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's break apart the code that we just ran:\n",
    "\n",
    "<code><font color='#33a1fd'><b># run \"Hello World\" program</b></font></code>\n",
    "\n",
    "is a comment and will not be considered as code by Python. Every line that starts with # is a comment. You can use comments for whatever you want, such as explaining what certain lines of code do. This is especially useful for when other people read your code!\n",
    "\n",
    "<code><font color='#33a1fd'><b>print()</b></font></code>\n",
    "\n",
    "is a function. Functions perform specific tasks. The <code><font color='#33a1fd'><b>print()</b></font></code> function takes in an input message and tells the computer to print that message to the screen.\n",
    "\n",
    "The input message we passed into our function was <font color='#33a1fd'><b>\"Hello World!\"</b></font>. Notice that we put quotation marks (\" \") around the message. Any series of characters with quotation marks around it is called a <font color='#33a1fd'><b>string</b></font>. Try changing the string that we pass into the print function!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello HER CODE seCAMP!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello HER CODE seCAMP!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also put single quotes (' ') around strings instead of double quotes (\" \"), they are equivalent!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello HER CODE CAMP!\n"
     ]
    }
   ],
   "source": [
    "print('Hello HER CODE CAMP!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only import thing to remember is that if we use one type of quotation mark, we can't use it anywhere else in the string since the computer won't know how to interpret it!\n",
    "\n",
    "We can run into problems if our strings have apostrophes in them..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-22-99f56e7a2e69>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-22-99f56e7a2e69>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    print('It's an awesome day today!')\u001b[0m\n\u001b[0m              ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print('It's an awesome day today!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...that's why it's generally safer to use double quotes around strings &#128578;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's an awesome day today!\n"
     ]
    }
   ],
   "source": [
    "print(\"It's an awesome day today!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#357DED'><h2>Section 2: VARIABLES</h2></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to print a string multiple times, it would get tiring typing it out each time. One thing we could do is assign the string to a <font color='#33a1fd'><b>variable</b></font>. You can think of a variable as bucket that stores information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"Hello HER CODE CAMP\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's break it down:\n",
    "\n",
    "<code><font color='#33a1fd'><b>message</b></font></code>\n",
    "\n",
    "is the name we are giving to the variable. Notice that we don't use quotation marks!\n",
    "\n",
    "<code><font color='#33a1fd'><b>=</b></font></code>\n",
    "\n",
    "is the <font color='#33a1fd'><b>assignment operator</b></font>. We use this to set a variable to some value. It works by assigning the value on the right-hand side of the <code><b>=</b></code> to the left-hand side. This is not the same as the <code><b>=</b></code> you see in math class!\n",
    "\n",
    "<code><font color='#33a1fd'><b>\"Hello HER CODE CAMP\"</b></font></code>\n",
    "\n",
    "is the value we are assigning to the variable. Now, instead of typing out each time, we can use the variable we created! Give it a try:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello HER CODE CAMP\n"
     ]
    }
   ],
   "source": [
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can pretty much name a variable whatever you want, as long as it follows some rules:\n",
    "\n",
    "<ol>\n",
    "    <li>It can only consist of alphabetic characters (so A-Z, a-z), digits (0-9) and the \"_\" character ...that means no spaces!</li>\n",
    "    <li>It can't <em>only</em> contain digits</li>\n",
    "    <li>The first character <em>cannot</em> be a digit</li>\n",
    "    <li>It should <em>not</em> be the name of an existing function, because this might cause issues if you want to use that function later in your code. For example, <code><b>print()</b></code> is already a function, so don't make a variable called <code><b>print</b></code>! If you are not sure whether or not your variable name is already a function, see if it turns blue when you type it. If it does, that means it is a function, so choose another variable name!</li>\n",
    "</ol>\n",
    "\n",
    "Remember, variables don't contain quotation marks! Here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = \"rock\"\n",
    "mon2fri = \"MondayTuesdayWednesdayThursdayFriday\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to change the value of our variable, we can rewrite the assignment statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"Player won the game :)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, when we call our <code><font color='#33a1fd'><b>print(message)</b></font></code> function, it will no longer print \"Hello HER CODE CAMP\". Instead, it will print the new value we assigned to our variable <code><font color='#33a1fd'><b>message</b></font></code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player won the game :)\n"
     ]
    }
   ],
   "source": [
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h3>Section 2.1: the input() function</h3></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code><font color='#33a1fd'><b>print()</b></font></code> isn't the only function we can use in Python. In fact, Python has a large variety of functions that we can use to do a whole bunch of things. We can use another function called <code><font color='#33a1fd'><b>input()</b></font></code>. The <code><font color='#33a1fd'><b>input()</b></font></code> function opens up a box where <em>you</em> can type something. Let's try it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also write a message that prompts the user to type in something specific. We do this by writing a string inside the <code><font color='#33a1fd'><b>input()</b></font></code> function, just like we did with the <code><font color='#33a1fd'><b>print()</b></font></code> function. For example, let's say we want the player of a rock, paper, scissors game to input their move. We might type something like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose your move: (rock, paper, or scissors)rock\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'rock'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input(\"Choose your move: (rock, paper, or scissors)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's one problem...one we've run that code, we can't access the word <code><font color='#33a1fd'><b>rock</b></font></code> anymore. Whatever the user typed in was lost. Instead, we can store what the user wrote in a <font color='#33a1fd'><b>variable</b></font> and then we can keep the input forever!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose your move: (rock, paper, or scissors)paper\n"
     ]
    }
   ],
   "source": [
    "player_move = input(\"Choose your move: (rock, paper, or scissors)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we have stored what you have written in the variable <code><font color='#33a1fd'><b>player_move</b></font></code>. Let's try printing it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "paper\n"
     ]
    }
   ],
   "source": [
    "print(player_move)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#357DED'><h2>Section 3: DATA TYPES</h2></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h3>Section 3.1: Numbers</h3></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python we can work with numbers. There are two main types of numerical data in Python:\n",
    "\n",
    "<ol>\n",
    "    <li>Integers</li>\n",
    "    <li>Floats</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h4>Section 3.1.a: Integers</h4></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#33a1fd'><b>Integers</b></font> mean the same thing as they do in math: they are whole numbers <em>(some examples of whole numbers are: 8, -9, 0)</em>. We can assign integers to variables. Here are some examples:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "score_Marta = 3\n",
    "score_computer = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we use our <code><font color='#33a1fd'><b>print()</b></font></code> function on these variables, the screen will print out the numbers we assigned to them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(score_Marta)\n",
    "print(score_computer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h4>Section 3.1.b: Floats</h4></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A <font color='#33a1fd'><b>float</b></font> is a number with one or more numbers after the decimal point. Here are some examples of floats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 3.14159\n",
    "b = 12.0\n",
    "c = 17890.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we're not sure about what type of number we assigned to a variable (e.g. if b=12.0, is b an integer or a float?) we can use the <code><font color='#33a1fd'><b>type()</b></font></code> function. Similar to the <code><font color='#33a1fd'><b>print()</b></font></code> and <code><font color='#33a1fd'><b>input()</b></font></code> functions, we type the function <code><font color='#33a1fd'><b>type()</b></font></code> (don't forget round brackets) and pass in an input. Here, I will pass in <code><font color='#33a1fd'><b>score_Marta</b></font></code> as an input because I want to see if the score I assigned was an integer or a float!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(score_Marta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Turns out it was an integer. Let's check another variable!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value of <code><font color='#33a1fd'><b>b</b></font></code> we wrote was a float, even though it's the number 12. The decimal is important!\n",
    "\n",
    "One of the cool things about coding is that we can do math with integers and floats on the computer. Your calculator is actually a small computer that performs the same operations!\n",
    "\n",
    "Let's go through some math operations that we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# ADDITION\n",
    "print(7 + 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n"
     ]
    }
   ],
   "source": [
    "# SUBTRACTION\n",
    "print(9.0 - 8.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36525.0\n"
     ]
    }
   ],
   "source": [
    "# MULTIPLICATION \n",
    "print(365.25 * 100)  # (Note that we can combine integers & floats in our operations!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "1.5\n"
     ]
    }
   ],
   "source": [
    "# DIVISION \n",
    "print(10 / 5) \n",
    "\n",
    "x = 3\n",
    "y = 2\n",
    "print(x / y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that when we do division with integers, the resulting answer is a float!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# EXPONENTIATION\n",
    "print(y**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also do more complicated operations, like this one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print((x + y*2)/7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the order of operations that was performed. Instead of going from left to right, we did the operations in the following order:\n",
    "\n",
    "<ol>\n",
    "    <li>y*2</li>\n",
    "    <li>(x + y*2)</li>\n",
    "    <li>(x + y*2)/7</li>\n",
    "</ol>\n",
    "\n",
    "This is the same as how we perform order of operations in algebra <b>(BEDMAS)</b>!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#b24c63'><h2>Exercise 1:</h2></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are the temperature values for next week from the Weather Network. Compute the mean (average) temperature for next week and print the result:\n",
    "\n",
    "<ul>\n",
    "    <li>monday:      &emsp;&emsp;&emsp;23</li>\n",
    "    <li>tuesday:     &emsp;&emsp;&emsp;22</li>\n",
    "    <li>wednesday:   &emsp;25</li>\n",
    "    <li>thursday:    &emsp;&emsp;&ensp;23</li>\n",
    "    <li>friday:      &emsp;&emsp;&emsp;&emsp;23</li>\n",
    "</ul>\n",
    "\n",
    "<em>Hint: the average is the sum of all the numbers divided by the number of numbers!</em>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we are adding a number to a variable multiple times, we can reassign the value of a variable to say that it equals itself plus something new (i.e., <code><font color='#33a1fd'><b>var = var + new</b></font></code>). We can also use a shortcut with <code><font color='#33a1fd'><b>+=</b></font></code> (i.e., <code><font color='#33a1fd'><b>var += new</b></font></code>): these two representations are equivalent!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "count = count + 1\n",
    "print(count)\n",
    "\n",
    "count += 1\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h3>Section 3.2: Booleans</h3></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do things with numbers other than math operations. For example, we can find out if one number is larger than the other! Or we test if two variables have the same value. When we compare two values, the output is either <code><font color='#33a1fd'><b>True</b></font></code> or <code><font color='#33a1fd'><b>False</b></font></code>. These are called <font color='#33a1fd'><b>booleans</b></font></code>. Here are some comparision operators:\n",
    "\n",
    "<ul>\n",
    "    <li><code><font color='#33a1fd'><b>==</b></font></code> &emsp; equal to</li>\n",
    "    <li><code><font color='#33a1fd'><b>!=</b></font></code> &emsp; not equal to</li>\n",
    "    <li><code><font color='#33a1fd'><b>&gt;</b></font></code> &emsp;&nbsp;&nbsp; greater than</li>\n",
    "    <li><code><font color='#33a1fd'><b>&gt;=</b></font></code> &emsp; greater than or equal to</li>\n",
    "    <li><code><font color='#33a1fd'><b>&lt;</b></font></code> &emsp;&nbsp;&nbsp; less than</li>\n",
    "    <li><code><font color='#33a1fd'><b>&lt;=</b></font></code> &emsp; less than or equal to</li>\n",
    "</ul>\n",
    "\n",
    "Here are some examples. Let's pretend someone is playing a game against the computer and we want to compare scores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# EQUAL TO\n",
    "computer_score = 1\n",
    "player_score = 1\n",
    "\n",
    "player_score == computer_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This outputs <code><font color='#33a1fd'><b>True</b></font></code> because <code><font color='#33a1fd'><b>player_score</b></font></code> and <code><font color='#33a1fd'><b>computer_score</b></font></code> are both 1!\n",
    "\n",
    "We are not limited to seeing if two numbers are equal, we can also see if two strings are equal!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "player_move = \"scissors\"\n",
    "computer_move = \"Scissors\"\n",
    "\n",
    "player_move == computer_move"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This outputs <code><font color='#33a1fd'><b>False</b></font></code> because <font color='#33a1fd'><b>\"scissors\"</b></font> and <font color='#33a1fd'><b>\"Scissors\"</b></font> aren't the same thing.\n",
    "\n",
    "We can also see if two things <em>aren't</em> equal. We do this using the  <code><font color='#33a1fd'><b>!=</b></font></code> operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NOT EQUAL TO\n",
    "player_move = \"rock\"\n",
    "computer_move =\"scissors\"\n",
    "player_move != computer_move"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This outputs <code><font color='#33a1fd'><b>True</b></font></code> because it's true that <font color='#33a1fd'><b>\"rock\"</b></font> and <font color='#33a1fd'><b>\"scissors\"</b></font> aren't the same thing!\n",
    "\n",
    "Let's say we play another round and the player wins. What if we want to check if  <code><font color='#33a1fd'><b>player_score</b></font></code> is now greater than <code><font color='#33a1fd'><b>computer_score</b></font></code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "player_score = 2 \n",
    "computer_score = 1\n",
    "\n",
    "player_score > computer_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also see if one item is <b>greater than <em>or</em> equal to</b> another item. Let's say the computer wins another round and we want to see if <code><font color='#33a1fd'><b>player_score</b></font></code> is greater than or equal to <code><font color='#33a1fd'><b>computer_score</b></font></code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "player_score = 2\n",
    "computer_score = 2\n",
    "\n",
    "player_score >= computer_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nice! We know that <code><font color='#33a1fd'><b>player_score</b></font></code> now has to be at least as large as <code><font color='#33a1fd'><b>computer_score</b></font></code>, if not greater.\n",
    "\n",
    "We can also use the less-than operator (<code><font color='#33a1fd'><b>&lt;</b></font></code>) to see if <code><font color='#33a1fd'><b>player_score</b></font></code> is less than <code><font color='#33a1fd'><b>computer_score</b></font></code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "player_score < computer_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This output makes sense, since we already checked that <code><font color='#33a1fd'><b>player_score</b></font></code> is at least as larger as <code><font color='#33a1fd'><b>computer_score</b></font></code> so there's no way it can be less than it! Let's see if <code><font color='#33a1fd'><b>computer_score</b></font></code> is less than *or* equal to <code><font color='#33a1fd'><b>player_score</b></font></code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_score <= player_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case both <code><font color='#33a1fd'><b>computer_score</b></font></code> and <code><font color='#33a1fd'><b>player_score</b></font></code> are 2. The output <code><font color='#33a1fd'><b>True</b></font></code> makes sense because <code><font color='#33a1fd'><b>computer_score</b></font></code> is at most equal to <code><font color='#33a1fd'><b>player_score</b></font></code>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#b24c63'><h2>Exercise 2:</h2></font>\n",
    "\n",
    "My goal every week is to run 10 km. If I pass my goal by Friday, I can buy myself an ice-cream on Saturday! Did I achieve my goal this week? Use a **boolean comparison**!\n",
    "\n",
    "<ul>\n",
    "    <li>monday:      &emsp;&emsp;&emsp;2.987 km</li>\n",
    "    <li>tuesday:     &emsp;&emsp;&emsp;1.123 km</li>\n",
    "    <li>wednesday:   &emsp;5.385 km</li>\n",
    "    <li>thursday:    &emsp;&emsp;&ensp;1.345 km</li>\n",
    "    <li>friday:      &emsp;&emsp;&emsp;&emsp;0.896 km</li>\n",
    "</ul>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h3>Section 3.3: Strings</h3></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have already seen this type of data. This is a sequence of characters wrapped in quotation marks. It can be as long as you want and can contain a combination of letters, numbers, and punctuation: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have 3 fluffy cats!\n"
     ]
    }
   ],
   "source": [
    "sentence = \"I have 3 fluffy cats!\"  \n",
    "print(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can combine strings by using the <code><font color='#33a1fd'><b>+</b></font></code> operator. We call this <code><font color='#33a1fd'><b>concatenation</b></font></code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ready set go\n"
     ]
    }
   ],
   "source": [
    "sentence = \"Ready \" + \"set \" + \"go\" \n",
    "print(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that when we combine strings we have to be very explicit in telling the computer what to print. We have to remember to include spaces at least somewhere in our text; otherwise we would get \"<em>Readysetgo</em>\" as a single word:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Readysetgo\n"
     ]
    }
   ],
   "source": [
    "bad_sentence = \"Ready\" + \"set\" + \"go\" \n",
    "print(bad_sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can't combine integers with strings directly, since they are two different data types. This will throw an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-49-6c1ce2447eba>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmonth\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"September\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mday\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m14\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Today is \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mmonth\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\" \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mday\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "month = \"September\"\n",
    "day = 14\n",
    "print(\"Today is \" + month + \" \" + day)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we <em>can</em> concatenate strings to integers if we convert the integer to a string first. The function <code><font color='#33a1fd'><b>str()</b></font></code> converts given data types into strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today is September 14\n"
     ]
    }
   ],
   "source": [
    "month = \"September\"\n",
    "day = 14\n",
    "print(\"Today is \" + month + \" \" + str(day))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#b24c63'><h2>Exercise 3:</h2></font>\n",
    "\n",
    "Given the following scores of a rock-paper-scissors game, print them out in a string like this:\n",
    "\n",
    "<code><font color='#33a1fd'><b>Player 1 = 2, Player 2 = 1</b></font></code>\n",
    "\n",
    "*Hint: convert the integer variables to strings*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 1 = 2, Player 2 = 1\n"
     ]
    }
   ],
   "source": [
    "# scores\n",
    "P1_score = 2\n",
    "P2_score = 1\n",
    "\n",
    "result = \"Player 1 = \" + str(P1_score)\n",
    "result += \", Player 2 = \" + str(P2_score)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can sort of think of a string as a list of individual characters. We can perform some neat operations on that string like picking out specific characters. This is called <font color='#33a1fd'><b>indexing</b></font>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters = \"ABC\" \n",
    "letters[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You probably noticed that we didn't use the number 1 to get the first character of the string. This is actually super common in programming languages where we might say that we have a string of length 10, but the first character is at <font color='#33a1fd'><b>index 0</b></font> and the last character is at <font color='#33a1fd'><b>index 9</b></font>. In general, we say that <font color='#33a1fd'><b>the character at position N can be indexed using N-1</b></font>. You can think of it as saying how far away the character is from the very first character: the first character is 0 spots away from the first character, so it gets an index of 0.\n",
    "\n",
    "We can use <font color='#33a1fd'><b>negative indices</b></font>, too. They count *backwards* from the end of the string (but start at 1 instead of 0):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters = \"ABC\"\n",
    "letters[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can find out the length of a string using the <code><font color='#33a1fd'><b>len()</b></font></code> function. We can use indices and the length to access the last part of a string. When we grab subsections of a string instead of a single character, we call it <font color='#33a1fd'><b>slicing</b></font>. We need to specify two indices separated with a colon (<font color='#33a1fd'><b>:</b></font>), where the first number is the start of the section we want to slice and the second number is the end of what we want to slice. The first number is included in our slice, but the last number is _not_; the index goes <font color='#33a1fd'><b>up to but not including</b></font> the final number: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "learning python!\n"
     ]
    }
   ],
   "source": [
    "sentence = \"We are learning python!\"\n",
    "length = len(sentence)\n",
    "print(length)\n",
    "\n",
    "print(sentence[7:length])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to remove characters from the end of the string, you can use a negative final index. Let's remove the exclamation point from our slice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'learning python'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence[7:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You actually don't need to define the indices if you want the whole string, you can use the colon directly. Python assumes that if you omit the initial index that you want a substring starting right from the beginning and that if you omit the final index you want a substring ending at the very end of the string: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABCD\n",
      "EFG\n",
      "EFG\n",
      "ABCDEFG\n"
     ]
    }
   ],
   "source": [
    "letters = \"ABCDEFG\"\n",
    "print(letters[:4])\n",
    "print(letters[4:])\n",
    "print(letters[-3:])\n",
    "print(letters[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check whether a string contains a substring by using the keyword <code><font color='#33a1fd'><b>in</b></font></code>. We can check whether the string *does not* contain a substring using <code><font color='#33a1fd'><b>not in</b></font></code>. Keywords aren't used in the same way as functions (they don't have brackets), but they are special words predefined in python to work a specific way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "numbers = \"0123456789\"\n",
    "print('0' in numbers)\n",
    "print('5' not in numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we've mastered strings, let's try splitting up the string into parts using the function <code><font color='#33a1fd'><b>split()</b></font></code>. The result of splitting a sentance on spaces is a <font color='#33a1fd'><b>list</b></font> of every word in the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['We', 'are', 'learning', 'python!']\n"
     ]
    }
   ],
   "source": [
    "sentence = \"We are learning python!\"\n",
    "print(sentence.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h3>Section 3.4: Lists</h3></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we've created a list from a string, let's talk about exactly what a list is in python. A <font color='#33a1fd'><b>list</b></font> is a sequence of items much like how a string was a sequence of characters, but with lists you have much more flexibility. Let's try making some lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_list = []\n",
    "empty_list = list()\n",
    "\n",
    "word_list = [\"A\", \"B\", \"C\", \"D\", \"E\"]\n",
    "number_list = [1, 2, 3, 4, 5]\n",
    "boolean_list = [True, True, False]\n",
    "mixed_list = [\"1\", 2, True]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create lists from variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 'World!']\n"
     ]
    }
   ],
   "source": [
    "x = \"Hello\"\n",
    "y = \"World!\"\n",
    "\n",
    "hello_world = [x, y]\n",
    "print(hello_world)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#b24c63'><h2>Exercise 4:</h2></font>\n",
    "\n",
    "Given variables for each possible move in rock-paper-scissors, create a list of the possible moves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "rock = 'rock'\n",
    "paper = 'paper'\n",
    "scissors = 'scissors'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<em>Solution:</em>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['rock', 'paper', 'scissors']\n"
     ]
    }
   ],
   "source": [
    "possible_moves = [rock, paper, scissors]\n",
    "print(possible_moves)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much like with strings we can get the length of the list using <code><font color='#33a1fd'><b>len()</b></font></code>. Recall that for strings the <code><font color='#33a1fd'><b>len()</b></font></code> function returns the number of <font color='#33a1fd'><b>characters</b></font> in the string. For lists, the <code><font color='#33a1fd'><b>len()</b></font></code> function returns the number of <font color='#33a1fd'><b>items</b></font> in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 11, 12]\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "my_list = [10, 11, 12]\n",
    "print(my_list)\n",
    "print(len(my_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember how we made some empty lists earlier? Those aren't very useful, but we can add elements to lists that have already been created using the <code><font color='#33a1fd'><b>append()</b></font></code> function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "['item']\n"
     ]
    }
   ],
   "source": [
    "my_list = []\n",
    "print(my_list)\n",
    "my_list.append(\"item\")\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also append lists to lists using the same syntax that we did for strings (using <code><font color='#33a1fd'><b>+</b></font></code>):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3,4,5]\n",
    "my_list += [6] # add a single element\n",
    "my_list += [7,8] # add multiple elements\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that to add a single element to a list you have to put it into square brackets (i.e., make it a list with one element). If we try to just add a single element that is not a list we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-66-dfca9b0065bd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmy_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmy_list\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3,4,5]\n",
    "my_list += 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do the exact same indexing and slicing operations we performed on strings with lists!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "[2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "last_number = numbers[-1] \n",
    "print(last_number)\n",
    "\n",
    "two_to_four = numbers[1:4]\n",
    "print(two_to_four)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can modify elements in a list, but only if you re-assign them using the assignment operator (i.e., <code><font color='#33a1fd'><b>=</b></font></code>):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[2, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "first_number = numbers[0]\n",
    "first_number += 1 # this doesn't modify the list because the variable is a copy\n",
    "print(numbers) \n",
    "\n",
    "numbers[0] += 1 # this does modify the list\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#b24c63'><h2>Exercise 5:</h2></font>\n",
    "\n",
    "You are given a list that keeps track of the current score of a match of rock-paper-scissors. The first element is the score for Player 1 and the second element is the score for Player 2. \n",
    "\n",
    "Player 1 just won the match, so we need to increment the score for Player 1 by indexing the list to get the first element and assigning it to its value plus 1.\n",
    "\n",
    "*Hint: Remember that you can do <code><font color='#33a1fd'><b>x = x + 1</b></font></code> or <code><font color='#33a1fd'><b>x += 1</b></font></code> to increment something!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_score = [0, 1] # player 1 just won the match so the list should become [1, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<em>Solution:</em>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1]\n"
     ]
    }
   ],
   "source": [
    "current_score[0] += 1\n",
    "print(current_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's often useful to sort lists, in alphabetical or numerical order. We can do that using the <code><font color='#33a1fd'><b>sort()</b></font></code> function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\n"
     ]
    }
   ],
   "source": [
    "alphabet = ['F', 'G', 'H', 'I', 'J', 'K', 'A', 'B', 'C', 'D', 'E', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'L', 'M', 'N', 'O', 'P', 'Q', 'R' ]\n",
    "alphabet.sort() \n",
    "print(alphabet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can only sort lists where elements are all of the same type. This is because comparison operations only work between the same data types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-73-a7b4108d5fbb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmixed_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m\"1\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"3\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"5\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmixed_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "mixed_list = [\"1\", 2, \"3\", 4, \"5\"]\n",
    "mixed_list.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check if an item appears in a list in the same way we checked if a character or word appeared in a string (with <code><font color='#33a1fd'><b>in</b></font></code> and <code><font color='#33a1fd'><b>not in</b></font></code>):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "pets = ['cat', 'hamster', 'dog']\n",
    "print('hamster' in pets) \n",
    "print('rat' not in pets) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#b24c63'><h2>Exercise 6:</h2></font>\n",
    "\n",
    "Use <code><font color='#33a1fd'><b>in</b></font></code> to determine if the given move is valid in rock-paper-scissors (i.e., one of rock, paper, or scissors). \n",
    "\n",
    "*Hint: recall that you created a list of the possible moves in exercise 4!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "move = 'rock'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<em>Solution:</em>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(move in possible_moves)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#357DED'><h2>Section 4: LOGIC</h2></font>\n",
    "\n",
    "**Logic** is a very important part of programming! It allows you to make decisions and repeat tasks. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h3>Section 4.1: Conditionals</h3></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#33a1fd'><b>Conditional statements</b></font> allow you to make decisions based on some data. We use an <code><font color='#33a1fd'><b>if</b></font></code> statement combined with a <font color='#33a1fd'><b>boolean expression</b></font> (we learned about those earlier) to make a decision.\n",
    "\n",
    "The syntax for an <code><font color='#33a1fd'><b>if</b></font></code> statement is to write <code><font color='#33a1fd'><b>if</b></font></code> followed by some boolean expression followed by a colon (i.e., <code><font color='#33a1fd'><b>:</b></font></code>) on one line, then create another line that is indented using 4 spaces. The \"body\" of the <code><font color='#33a1fd'><b>if</b></font></code> statement is this indented line; you can have multiple lines in the body as long as you indent them all. This is where you tell the computer what you want to happen if your boolean expression is correct!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "x was 5\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "if x == 5:\n",
    "  print(x)\n",
    "  print(\"x was 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that <font color='#33a1fd'><b>the entire body must be indented</b></font>; any unindented parts will be executed even if the condition is not met!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x was 5\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "if x == 5:\n",
    "  print(x)\n",
    "print(\"x was 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This only lets us handle one possibility, but we can also support the opposite case  using <code><font color='#33a1fd'><b>else</b></font></code>. By saying <code><font color='#33a1fd'><b>else</b></font></code> we are handling whatever inputs are not considered by the <code><font color='#33a1fd'><b>if</b></font></code> statement. The <code><font color='#33a1fd'><b>else</b></font></code> is put on a new line and is *not* indented (it should be lined up with the <code><font color='#33a1fd'><b>if</b></font></code>), but the body of the <code><font color='#33a1fd'><b>else</b></font></code> statement needs to be indented like the body of the <code><font color='#33a1fd'><b>if</b></font></code> statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x was not 5\n"
     ]
    }
   ],
   "source": [
    "x = 6\n",
    "if x == 5:\n",
    "  print(\"x was 5\")\n",
    "else: # x != 5\n",
    "  print(\"x was not 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also make more complex decisions by using <code><font color='#33a1fd'><b>elif</b></font></code> (else-if). Note that we can chain together <code><font color='#33a1fd'><b>if</b></font></code>-<code><font color='#33a1fd'><b>elif</b></font></code>-<code><font color='#33a1fd'><b>else</b></font></code> statements!. You can define as many <code><font color='#33a1fd'><b>elif</b></font></code> statements as you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x was negative\n"
     ]
    }
   ],
   "source": [
    "x = -2\n",
    "if x > 0:\n",
    "  print(\"x was positive\")\n",
    "elif x < 0:\n",
    "  print(\"x was negative\")\n",
    "else:\n",
    "  print(\"x was neither positive nor negative\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#b24c63'><h2>Exercise 7:</h2></font>\n",
    "\n",
    "You are given the result of a game as a list where the first element is the number of rounds Player 1 won and the second element is the number of rounds Player 2 won. \n",
    "- If Player 1 has a higher score than Player 2, print a message stating that Player 1 is winning the game.\n",
    "- If Player 2 has a higher score than Player 1, print a message stating that Player 2 is winning the game.\n",
    "- Otherwise, print a message stating that they are tied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_score = [0, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<em>Solution:</em>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 1 is winning!\n"
     ]
    }
   ],
   "source": [
    "if current_score[0] > current_score[1]:\n",
    "  print(\"Player 1 is winning!\")\n",
    "elif current_score[1] > current_score[0]:\n",
    "  print(\"Player 1 is winning!\")\n",
    "else:\n",
    "  print(\"The players are tied.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can put <code><font color='#33a1fd'><b>if</b></font></code> statements in the body of another <code><font color='#33a1fd'><b>if</b></font></code> statement if you want to! This is called <font color='#33a1fd'><b>nesting</b></font>: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "both x and y were positive\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = 10\n",
    "\n",
    "if x > 0:\n",
    "  if y > 0:\n",
    "    print(\"both x and y were positive\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#b24c63'><h2>Exercise 8:</h2></font>\n",
    "\n",
    "Given the move that each player made, print which player won the match or if there was a tie. We've provided you with some code that handles the case where player 1 chose rock. Modify the <code><font color='#33a1fd'><b>XXXX</b></font></code> in the identified lines to correctly handle other inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-84-eff3880d1867>, line 18)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-84-eff3880d1867>\"\u001b[0;36m, line \u001b[0;32m18\u001b[0m\n\u001b[0;31m    elif XXXX XX XXXX:          # (*) TODO: check if player 1 played paper\u001b[0m\n\u001b[0m               ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "player_1 = \"paper\"\n",
    "player_2 = \"scissors\"\n",
    "\n",
    "if player_1 == \"rock\": \n",
    "  if player_2 == \"scissors\":\n",
    "    print(\"Player 1 won the match\")\n",
    "  elif player_2 == \"paper\":\n",
    "    print(\"Player 2 won the match\")\n",
    "  else:\n",
    "    print(\"The match was tied\")\n",
    "elif player_1 == \"XXXX\":    # (*) TODO: check if player 1 played scissors\n",
    "  if player_2 == \"XXXX\":    # (*) TODO: create a condition that would mean player 1 won\n",
    "    print(\"Player 1 won the match\")\n",
    "  elif player_2 == \"XXXX\":  # (*) TODO: create a condition that would mean player 2 won\n",
    "    print(\"Player 2 won the match\")\n",
    "  else:\n",
    "    print(\"The match was tied\")\n",
    "elif XXXX XX XXXX:          # (*) TODO: check if player 1 played paper\n",
    "  if XXXX XX XXXX:          # (*) TODO: create a condition that would mean player 1 won\n",
    "    print(\"Player 1 won the match\") \n",
    "  elif XXXX XX XXXX:        # (*) TODO: create a condition that would mean player 2 won\n",
    "    print(\"Player 2 won the match\")\n",
    "  else:\n",
    "    print(\"The match was tied\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<em>Solution:</em>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 2 won the match\n"
     ]
    }
   ],
   "source": [
    "player_1 = \"paper\"\n",
    "player_2 = \"scissors\"\n",
    "\n",
    "if player_1 == \"rock\": \n",
    "  if player_2 == \"scissors\":\n",
    "    print(\"Player 1 won the match\")\n",
    "  elif player_2 == \"paper\":\n",
    "    print(\"Player 2 won the match\")\n",
    "  else:\n",
    "    print(\"The match was tied\")\n",
    "elif player_1 == \"scissors\": \n",
    "  if player_2 == \"paper\":\n",
    "    print(\"Player 1 won the match\")\n",
    "  elif player_2 == \"rock\":\n",
    "    print(\"Player 2 won the match\")\n",
    "  else:\n",
    "    print(\"The match was tied\")\n",
    "else: # player 1 chose paper\n",
    "  if player_2 == \"rock\":\n",
    "    print(\"Player 1 won the match\")\n",
    "  elif player_2 == \"scissors\":\n",
    "    print(\"Player 2 won the match\")\n",
    "  else:\n",
    "    print(\"The match was tied\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h3>Section 4.2: Loops</h3></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loops allow you to repeat tasks and come in two flavours: \n",
    "\n",
    "1.   Counting loops (for loops)\n",
    "2.   Conditional loops (while loops)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h4>Section 4.2.a: Counting loops (for-loops)</h4></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#33a1fd'><b>Counting loops</b></font> repeat a certain number of times; we call these <code><font color='#33a1fd'><b>for-loops</b></font></code> because they **occur once for every specified item**. For example, this could be for each element in a list.\n",
    "\n",
    "Like <code><font color='#33a1fd'><b>if</b></font></code> statements, the syntax for a loop is to write the <code><font color='#33a1fd'><b>for</b></font></code> statement on one line then to indent the body using 4 spaces. The <code><font color='#33a1fd'><b>for</b></font></code> statement consists of the keyword <code><font color='#33a1fd'><b>for</b></font></code> followed by a variable name followed by the keyword <code><font color='#33a1fd'><b>in</b></font></code> followed by a list. The letters <code><font color='#33a1fd'><b>i</b></font></code>, <code><font color='#33a1fd'><b>j</b></font></code>, and <code><font color='#33a1fd'><b>k</b></font></code> are commonly used to represent the **iterations** (number of repeats) of a loop, but you can define any variable name. \n",
    "\n",
    "Note that, just like with <code><font color='#33a1fd'><b>if</b></font></code> statements, the *entire body* must be indented or any unindented parts will be executed *outside* of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in [0, 1, 2, 3, 4, 5]:\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of directly initializing the list, we can also use the <code><font color='#33a1fd'><b>range()</b></font></code> function to generate a list. This is convenient when you want a loop to repeat a large number of times. Note that the argument given to <code><font color='#33a1fd'><b>range()</b></font></code> is **non-inclusive**, so <code><font color='#33a1fd'><b>range(6)</b></font></code> will not include the number 6 (but it *will* include the number 0):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for j in range(6): # create a list from 0 to 5\n",
    "  print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the same syntax to iterate over the elements of *any* list, the list doesn't have to consist of numbers!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\n",
      "dog\n",
      "hamster\n"
     ]
    }
   ],
   "source": [
    "pets = ['cat', 'dog', 'hamster']\n",
    "for pet in pets:\n",
    "  print(pet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#31393c'><h4>Section 4.2.b: Counting loops (while \n",
    "   loops)</h4></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Conditional loops** repeat until a condition is no longer satisfied; we call these <code><font color='#33a1fd'><b>while loops</b></font></code> because they **repeat while a condition is true**. The condition is specified in a boolean expression. A <code><font color='#33a1fd'><b>while</b></font></code> loop can do the same thing as a <code><font color='#33a1fd'><b>for</b></font></code> loop as long as the condition is met. This means that usually something is written inside the body of the loop that might change the condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i <= 5: \n",
    "  print(i)\n",
    "  i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example we sum the numbers from 0 to 10 using a loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "loop_sum = 0\n",
    "i = 0\n",
    "\n",
    "while i <= 10:\n",
    "  loop_sum += i\n",
    "  i += 1\n",
    "  \n",
    "print(loop_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use <code><font color='#33a1fd'><b>break</b></font></code> to get yourself out of a loop before it would normally end. This combined with <code><font color='#33a1fd'><b>if</b></font></code> statements is powerful:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n",
      "528\n"
     ]
    }
   ],
   "source": [
    "loop_sum = 0\n",
    "i = 0\n",
    "\n",
    "while i <= 100: \n",
    "  loop_sum += i\n",
    "  \n",
    "  if loop_sum >= 500:\n",
    "    print(i)\n",
    "    break\n",
    "    \n",
    "  i += 1\n",
    "    \n",
    "print(loop_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#b24c63'><h2>Exercise 9:</h2></font>\n",
    "\n",
    "You are given the skeleton code for a loop that asks for the moves of player 1 and player 2 using the <code><font color='#33a1fd'><b>input</b></font></code> function. It runs until 3 matches have been played. The <code><font color='#33a1fd'><b>match_count</b></font></code>should increment with each round, but *not* if the players choose the same move and tie a match (they should replay that match instead). If any user inputs an invalid move, the loop will exit. Change <code><font color='#33a1fd'><b>XXXX</b></font></code> as indicated with the appropriate code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-92-a51ed8f6984c>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-92-a51ed8f6984c>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    while match_count XX XXXX: # (*) TODO: write a condition that will execute the loop while fewer than 3 matches have been played\u001b[0m\n\u001b[0m                       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "match_count = 0\n",
    "valid_moves = ['rock', 'paper', 'scissors']\n",
    "\n",
    "while match_count XX XXXX: # (*) TODO: write a condition that will execute the loop while fewer than 3 matches have been played\n",
    "  player_1 = input(\"Player 1 move: \")\n",
    "  if XXXX XX XXXX: # (*) TODO: check if player 1's input is not a valid move (hint: use \"not in\")\n",
    "    print(\"Invalid entry, check your spelling\")\n",
    "    break\n",
    "  \n",
    "  player_2 = input(\"Player 2 move: \")\n",
    "  if XXXX XX XXXX: # (*) TODO: check if player 2's input is not a valid move (hint: use \"not in\")\n",
    "    print(\"Invalid entry, check your spelling\")\n",
    "    break\n",
    "  \n",
    "  if XXXX XX XXXX: # (*) TODO: check that the players did not choose the same move\n",
    "    match_count += 1\n",
    "\n",
    "# print a message to indicate the game is over\n",
    "print(\"The game is over\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<em>Solution:</em>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player 1 move: rock\n",
      "Player 2 move: paper\n",
      "Player 1 move: rock\n",
      "Player 2 move: rock\n",
      "Player 1 move: rock\n",
      "Player 2 move: rock\n",
      "Player 1 move: rock\n",
      "Player 2 move: rock\n",
      "Player 1 move: rock\n",
      "Player 2 move: rock\n",
      "Player 1 move: \n",
      "Invalid entry, check your spelling\n",
      "The game is over\n"
     ]
    }
   ],
   "source": [
    "match_count = 0\n",
    "valid_moves = ['rock', 'paper', 'scissors']\n",
    "\n",
    "while match_count < 3: \n",
    "  player_1 = input(\"Player 1 move: \")\n",
    "  if player_1 not in valid_moves: \n",
    "    print(\"Invalid entry, check your spelling\")\n",
    "    break\n",
    "    \n",
    "  player_2 = input(\"Player 2 move: \")\n",
    "  if player_2 not in valid_moves: \n",
    "    print(\"Invalid entry, check your spelling\")\n",
    "    break\n",
    "  \n",
    "  if player_1 != player_2: \n",
    "    match_count += 1\n",
    "\n",
    "# print a message to indicate the game is over\n",
    "print(\"The game is over\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='#4857E2'><h1>Putting it all together: <em>Rock, Papers, Scissors!</em></h1></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we're going to combine everything that we've learned so far today into our game of rock-paper-scissors! We've given you some skeleton code below identifying all of the bits you need to fill in; every line with a comment that says <code><font color='#33a1fd'><b>(*)TODO</b></font></code> has at least one <code><font color='#33a1fd'><b>XXXX</b></font></code> that needs to be modified. We've provided some hints that will point you to different exercises that you've already completed in order to help you fill in the code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-94-df3daa308081>, line 8)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-94-df3daa308081>\"\u001b[0;36m, line \u001b[0;32m8\u001b[0m\n\u001b[0;31m    while XXXX XX XXXX:                # (*) TODO: create a condition that will check how many matches should be played (see exercise 9)\u001b[0m\n\u001b[0m                ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "from random import randint         # import an extra function for us to use\n",
    "\n",
    "valid_moves = [XXX, XXX, XXX]      # (*) TODO: create a list of valid moves (see exercise 4)\n",
    "\n",
    "score = [0, 0]                     # two scores: score[0] is the player and score[1] is the computer\n",
    "match = 0                          # the current number of matches that have been played\n",
    "\n",
    "while XXXX XX XXXX:                # (*) TODO: create a condition that will check how many matches should be played (see exercise 9) \n",
    "                                   # -> Question: why should this number be odd?\n",
    "    \n",
    "  player_move = input(\"XXXX: \")    # (*) TODO: write a message to appear when you are prompted to type in your move, (see section 2.1)\n",
    "  if XXXX XX XXXX:                 # (*) TODO: add a check if the move is *not* a valid move (see exercise 9)\n",
    "    print(\"Invalid move! Check spelling\")\n",
    "    break\n",
    "  \n",
    "  i = randint(0,2)                 # this code picks an integer between 0 and 2 at random\n",
    "  computer_move = valid_moves[i]   # we use this random integer to pick a move for the computer\n",
    "  print(\"XXXX\")                    # (*) TODO: print a message to describe the move the computer played (see section 1)\n",
    "  \n",
    "  # if the player and the computer chose the same move, we have to replay the match so don't increase the match count\n",
    "  if player_move == computer_move:\n",
    "    print(\"Tied, replaying round\")\n",
    "    \n",
    "  # otherwise they chose different moves\n",
    "  else:               \n",
    "    match += 1                    # increase the match number by 1 because the player and computer chose different moves\n",
    "    \n",
    "    # first possibility: you chose rock\n",
    "    if player_move == 'rock':\n",
    "      if computer_move == 'scissors':\n",
    "        score[0] += 1             # increase your score by 1, since you won this match\n",
    "        print(\"Rock beats scissors! You win this round!\")\n",
    "      else:   # comp = paper\n",
    "        score[1] += 1             # increase computer's score by 1, since the computer won this match\n",
    "        print(\"Paper beats rock! Computer wins this round!\")\n",
    "\n",
    "    # second possibility: you chose paper\n",
    "    elif XXXX XX XXXX:            # (*) TODO: change to a condition that will check if the player played paper (see section 3.2)\n",
    "      if XXXX XX XXXX:            # (*) TODO: change to a condition that will check if the computer played scissors (see section 3.2)\n",
    "        XXXX                      # (*) TODO: add code to increase the score for the winner by 1 (see exercise 5)\n",
    "        print(\"XXXX\")             # (*) TODO: print a message indicating the result and who won the round\n",
    "      else:                   \n",
    "        XXXX                      # (*) TODO: add code to increase the score for the winner by 1 (see exercise 5)\n",
    "        print(\"XXXX\")             # (*) TODO: print a message indicating the result and who won the round\n",
    "\n",
    "    # third possibility: you chose scissors\n",
    "    else:\n",
    "      if XXXX XX XXXX:            # (*) TODO: change to a condition that will check if the computer played rock\n",
    "        XXXX                      # (*) TODO: add code to increase the score for the winner by 1 (see exercise 5) \n",
    "        print(\"XXXX\")             # (*) TODO: print a message indicating the result and who won the round\n",
    "      else:\n",
    "        XXXX                      # (*) TODO: add code to increase the score for the winner by 1 (see exercise 5)\n",
    "        print(\"XXXX\")             # (*) TODO: print a message indicating the result and who won the round\n",
    "\n",
    "# after all matches are played, describe final result\n",
    "if XXXX XX XXXX:                  # (*) TODO: change to a condition that checks if the player won (see exercise 7)\n",
    "  print(\"XXXX\")                   # (*) TODO: print a message for when you win overall\n",
    "elif XXXX XX XXXX:                # (*) TODO: change to a condition that checks if the computer won (see exercise 7)\n",
    "  print(\"XXXX\")                   # (*) TODO: print a message for when the computer wins overall"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<em>Solution:</em>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint         # import an extra function for us to use\n",
    "\n",
    "valid_moves = ['rock', 'paper', 'scissors']                 \n",
    "\n",
    "score = [0, 0]                     # two scores, score[0] is the player and score[1] is the computer\n",
    "match = 0                          # the current number of matches that have been played\n",
    "\n",
    "while match < 3:                   # -> Question: why should this number be odd?\n",
    "    \n",
    "  player_move = input(\"Choose your move: \")            \n",
    "  if player_move not in valid_moves:\n",
    "    print(\"Invalid move! Check spelling\")                        \n",
    "    break\n",
    "  \n",
    "  i = randint(0,2)                 # this code picks an integer between 0 and 2 at random\n",
    "  computer_move = valid_moves[i]   # we use this random integer to pick a move for the computer\n",
    "  \n",
    "  print(\"Computer chose \" + computer_move)\n",
    "  \n",
    "  # if the player and the computer chose the same move, we have to replay the match so don't increase the match count\n",
    "  if player_move == computer_move:\n",
    "    print(\"Tied, replaying round\")\n",
    "    \n",
    "  # otherwise they chose different moves\n",
    "  else:               \n",
    "    match += 1                    # increase the match number by 1 because the player and computer chose different moves\n",
    "    \n",
    "    # first possibility: you chose rock\n",
    "    if player_move == 'rock':\n",
    "      if computer_move == 'scissors':\n",
    "        score[0] += 1             # increase your score by 1, since you won this match\n",
    "        print(\"Rock beats scissors! You win this round!\")\n",
    "      else:   # comp = paper\n",
    "        score[1] += 1             # increase computer's score by 1, since the computer won this match\n",
    "        print(\"Paper beats rock! Computer wins this round!\")\n",
    "\n",
    "    # second possibility: you chose paper\n",
    "    elif player_move == 'paper': \n",
    "      if computer_move == 'scissors':\n",
    "        score[1] += 1\n",
    "        print(\"Scissors beats paper! Computer wins this round!\")\n",
    "      else:                   \n",
    "        score[0] += 1\n",
    "        print(\"Paper beats rock! You win this round!\")\n",
    "\n",
    "    # third possibility: scissors\n",
    "    else:\n",
    "      if computer_move == 'rock':\n",
    "        score[1] += 1\n",
    "        print(\"Rock beats scissors! Computer wins this round!\")\n",
    "      else:\n",
    "        score[0] += 1\n",
    "        print(\"Scissors beats paper! You win this round!\")\n",
    "\n",
    "# after all matches are played, describe final result\n",
    "if score[0] > score[1]:                         \n",
    "  print(\"Player won the game :)\")                         \n",
    "elif score[1] > score[0]:                       \n",
    "  print(\"Computer won the game :(\")                        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}