Session 1b - Conditions and Logic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Session 1b: Conditions and Logic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: This is a **JUPYTER NOTEBOOK**. It's a type of website where you can edit and run computer programs (code). \n",
    "You interact with it in your web browser and you can access it via Noteable and Github.\n",
    "\n",
    "1. These blocks here are cells.\n",
    "2. There are **TEXT CELLS** like this one with explanations of concepts.\n",
    "3. And **CODE CELLS** with Python code (see below). \n",
    "4. You can **RUN CODE CELLS** by clicking on them and pressing **Shirt + Enter**. When you run a cell code in it is run (it \"happens\", computer will do what you asked for it to do). Results of what your code does will appear underneath the cell.\n",
    "5. As we go through these lessons, please READ text cells, and RUN code cells.\n",
    "6. Good luck!\n",
    "\n",
    "✅ Remember to RUN ALL THE CELLS IN ORDER AS YOU GO THROUGH THIS NOTEBOOK (if you skip some, you might see some unexpected errors)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 🎯 Learning objectives:\n",
    "\n",
    "At the end of this notebook you will know:\n",
    "\n",
    "- Comparing variables with == returns True or False.\n",
    "- 'if-elif-else' controls, which lines of code are executed and which are skipped, using True or False values.\n",
    "- How to refactor your code so that it is easier to debug.\n",
    "- Indentation (spaces on the left) indicates how python should understand code.\n",
    "- Logic combining many Trues and Falses into one value, like: True and True, False or True, not True.\n",
    "\n",
    "### 🔜 SPOILER ALERT:\n",
    "\n",
    "You will also understand these lines of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# variable types (colours and brackets are your friends)\n",
    "distance = 9\n",
    "name = 'Fiona'\n",
    "in_the_room = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comparisons:\n",
    "print(name == 'Fiona')\n",
    "print('Fiona' != 'Pat') # left is NOT equal to right\n",
    "print(name != 'Pat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(30 < 20)\n",
    "print(distance >= 10)\n",
    "print(in_the_room != False) # Statement is NOT equal to False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# All together:\n",
    "name = \"Fiona\"\n",
    "is_this_fiona = name == \"Fiona\" # Remember, right hand side of '=' happens first.\n",
    "print(is_this_fiona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conditions:\n",
    "speed = 10\n",
    "speed_camera_on = True\n",
    "\n",
    "if speed_camera_on == True:  # Could be simplified to just: 'if speed_camera_on:' i/e. a True statement.\n",
    "    if speed == 0:\n",
    "         print(\"You're not moving\")\n",
    "    elif speed > 20:\n",
    "        print(\"Please slow down, this is a TWENTY IS PLENTY zone\")\n",
    "    else:\n",
    "        print(\"Thank you for driving safely at\",speed,\"miles per hour!\")\n",
    "else:\n",
    "    print(\"Speed camera is off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Logic:\n",
    "if name == \"Fiona\" and distance <= 10 and in_the_room:\n",
    "    # Is this True? Notice that saying just in_the_room is like saying in_the_room == True.\n",
    "    print(\"Fiona is present and nearby\")\n",
    "else:\n",
    "    print(\"Person is not around, or not nearby or it's not Fiona\")\n",
    "    # Change the name, and/or distance, and/or in_the_room = False, to see what prints instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 🎯 End of learning objectives 🎯"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison operator '=='. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**COMPARISON OPERATOR ==** Often it is very useful to know if two variables hold the same value. \n",
    "This is where we would use a comparison operator '==' (written as 'equals sign' twice). \n",
    "It compares what's on the right side and left side of ```==``` and will return ```True``` if both sides are identical, and ```False``` if they are different."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can compare values.\n",
    "print( 22 == 22 )\n",
    "print( \"Banana\" == \"Banana\")\n",
    "print(22 == \"Banana\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can compare values and variables, or two variables.\n",
    "age = 23\n",
    "fruit = \"Apple\"\n",
    "\n",
    "print( fruit == age)\n",
    "print( age == 22 )\n",
    "print( age == 23 )\n",
    "print( fruit == \"Banana\" )\n",
    "print( fruit == \"Apple\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notice that compared values have to be IDENTICAL. This includes large and small letters\n",
    "fruit = \"Apple\"\n",
    "print( fruit == \"Apple\" )\n",
    "print( fruit == \"apple\" )\n",
    "print( fruit == \"aPPle\" )\n",
    "print( fruit == \"  Apple\" )\n",
    "print( fruit == \"Apple.\" )\n",
    "print( fruit == \"🍎\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional logic: If something do THIS else do THAT."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computer programs are most useful if we can control the flow of the program, the order in which lines of code are executed, or indeed which lines of code are executed at all. \n",
    "In all of the previous code examples, our code was evaluated, which is quite limiting. \n",
    "It would mean that each of our programs will have to happen always in the order that it was written. \n",
    "\n",
    "One of the most powerful concepts in programming is that we can control the order in which lines of code will be run (evaluate/happen)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if True:\n",
    "    print(\"This will happen!\")\n",
    "else:\n",
    "    print(\"Nope, this will never happen!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 2 == 2:\n",
    "    print(\"This will happen!\")\n",
    "else:\n",
    "    print(\"Nope, this will never happen!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notice that 2 == 2 is true, so it will evaluate to True i.e cell will return True. \n",
    "2 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 2\n",
    "if number == 3:\n",
    "    print(\"Oh? what will happen?\")\n",
    "else:\n",
    "    print(\"Oh! or this!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We'll talk about this later, but \"1999\" and 1999 are not the same, because their 'Type' is different (string versus integar).\n",
    "year_as_string = \"19\"+\"99\"\n",
    "if year_as_string == 1999: # This code will be evaluated (run) to check if it is True.\n",
    "    print(\"Oh? what will happen?\")\n",
    "else:\n",
    "    print(\"Oh! or this!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "should_i_say_hello = True\n",
    "if should_i_say_hello: # The first branch of 'if' will happen 'if' the value here is True.\n",
    "    print(\"Hello!\")\n",
    "else:\n",
    "    print(\"Bye!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Format of an if statement is as follows:\n",
    "\n",
    "```\n",
    "if <something that is True or False> :\n",
    "    <code that will happen if it is True>\n",
    "else:\n",
    "    <code that will happen if it is False>\n",
    "```\n",
    "\n",
    "We already know that the result of a comparison operator == is always True or False, so most of the time if else statements will look like this: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 5\n",
    "if number == 7:\n",
    "    print(\"This is a lucky number!\")\n",
    "else:\n",
    "    print(\"This is just a number!\")\n",
    "\n",
    "# Why not play at changing the values of the variables as we go e.g. number = 7, \n",
    "# to see what the outcome of the print is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In a well written code there should be a way to reach each branch of 'if-else' statement. \n",
    "# What if we change variable value in above code?    \n",
    "number = 7\n",
    "if number == 7:\n",
    "    print(\"This is a lucky number!\")\n",
    "else:\n",
    "    print(\"This is just a number!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These logical statements can be much more complicated. You can also use an \"else if\" statements, in python these are written as ```elif```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day = input(\"What day is it today?\")\n",
    "\n",
    "if day == \"Sunday\":\n",
    "    print(\"Yay! It's weekend!\")\n",
    "elif day == \"Saturday\":\n",
    "    print(\"Yay! It's weekend!\")\n",
    "elif day == \"Friday\":\n",
    "    print(\"It's a weekday!\")\n",
    "elif day == \"Thursday\":\n",
    "    print(\"It's a weekday!\")\n",
    "elif day == \"Wednesday\":\n",
    "    print(\"It's a weekday!\")\n",
    "elif day == \"Tuesday\":\n",
    "    print(\"It's a weekday!\")\n",
    "elif day == \"Monday\":\n",
    "    print(\"It's a weekday!\")\n",
    "else:\n",
    "    print(\"You typed\",day,\"which does not look like a day of the week!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You probably noticed that some parts of the above code feel a bit messy and repetitive. \n",
    "That's why we can use logical statement OR to 'DRY' up our code (make it more efficient and tidy)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a cleaner version of the above code (skipping input here, but feel free to add it).\n",
    "day = \"Saturday\"\n",
    "if day == \"Sunday\" or day == \"Saturday\":\n",
    "    print(\"Yay! It's weekend!\")\n",
    "elif day == \"Friday\"or day == \"Thursday\" or day == \"Wednesday\" or day == \"Tuesday\"or day == \"Monday\":\n",
    "    print(\"It's a weekday!\")\n",
    "else:\n",
    "    print(\"You typed\",day,\"which does not look like a day of the week!\")\n",
    "\n",
    "# Again, try to change the values of the variables to reach a different result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that only one section of the code is evaluated. Once an 'if' statement reaches something that is True, if will evaluate the following code and jump to the end.\n",
    "\n",
    "Often 'if' statements evaluate a number of different conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In 'if-elif-else' statements, only ONE block of code will be executed: THE FIRST CONDITION THAT IS TRUE.\n",
    "number = 7\n",
    "if number >= 3:\n",
    "    print(\"number is larger or equal to 3\") # THIS WILL PRINT.\n",
    "elif number >= 0:\n",
    "    print(\"this is a positive number\") # This won't, unless we change the value of 'number'.\n",
    "elif number == 7:\n",
    "    print(\"this is seven!\") # This won't, unless we change the value of 'number'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# But if these were completely independent 'if' statements, each condition would be considered separately, one by one.\n",
    "number = 7\n",
    "if number >= 3:\n",
    "    print(\"number is larger or equal to 3\")\n",
    "    \n",
    "if number >= 0:\n",
    "    print(\"this is a positive number\")\n",
    "    \n",
    "if number == 7:\n",
    "    print(\"this is seven!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Look carefully at above examples. It is good practise to try to figure out what a code will do BEFORE you run it. \n",
    "You can do it in your head or on paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here's a more complex example: Imagine a shop opened every day 8-22 apart of Sundays.\n",
    "time_now = 23\n",
    "day_of_the_week = \"Saturday\"\n",
    "\n",
    "if day_of_the_week == \"Sunday\":\n",
    "    print(\"Shop is completely closed today\")\n",
    "elif time_now < 8 or time_now  > 22:\n",
    "    print(\"Shop is not open at this time today\")\n",
    "else:\n",
    "    print(\"Shop is open\")\n",
    "    \n",
    "print(\"Thank you for checking\")\n",
    "\n",
    "# Try changing the values of the variables to reach a range of different results. \n",
    "# Note that 'time_now' is 24hr clock e.g 14 = 2pm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that above, because first condition ```day_of_the_week == \"Sunday\"``` is True, the code won't ever go to check if ```time_now < 8 or time_now  > 22```. It will print the \"Shop is closed today\" and then skip to the end of the 'if-else' statement and print \"Thank you for checking\".\n",
    "\n",
    "**IN IF-ELIF-ELSE ORDER MATTERS**: It is important to arrange your 'if' and 'elif' statements in order of importance, because only code within the first True condition will run."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indentation (empty space in your code at the left of the line). Written with 'Tab ➡' button on your keyboard."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many languages use brackets or special words to indicate where a conditional statement like 'if-else' starts and ends. \n",
    "Python uses indentation (empty space) instead. \n",
    "Notice that above there is a 'Tab' (keyboard key with -->| on it) to the left of every block of code following an 'if-else' statement. \n",
    "That's how python knows that the following lines of code should only happen in certain conditions.\n",
    "\n",
    "One way to visualise this, is like a train line where the train can be redirected right or left based on how the train tracks are set up.\n",
    "\n",
    "Often there are a series of better ways, but you could write code like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 8 \n",
    "# Change 8 to another number and run this line of code many times. Try to reach each branch with print().\n",
    "\n",
    "if number > 1:\n",
    "    if number < 10:\n",
    "        if number <= 4:\n",
    "            print(\"number is between 1 and 3\")\n",
    "        elif number <= 7:\n",
    "            print(\"number is between 4 and 7\")\n",
    "        else:\n",
    "            print(\"number is between 8 and 9\")\n",
    "    else: \n",
    "        print(\"number is larger than 10\")\n",
    "else:\n",
    "    print(\"number is smaller or equal to 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see above, indentation (spacing on the left) is crucial in Python. \n",
    "It is used to identify where your 'if-else' statements start and end.\n",
    "\n",
    "Always indent with 'TAB' key (keyboard key with -->| on it), not with spaces. It is much safer, accurate and easier.\n",
    "\n",
    "So if your indentation is wrong you will encounter another range of errors, see below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 3\n",
    "if number > 1:\n",
    "print(\"number is larger than 1\")\n",
    "\n",
    "# This will error. FIRST Read the error, follow the small arrow that's trying to help, and ONLY THEN try to fix it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logic, simple introduction - and, or, not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use logic operators ('and, or, not') to build more complicated statements. \n",
    "A very good way to do this well, is to pototype it on paper, or otherwise consider all the possible cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You have already seen some simple logic operations like this.\n",
    "number = 8\n",
    "if number > 1 and number < 10:\n",
    "    print(\"This number is between 1 and 10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 8\n",
    "if number == 2 or number == 4 or number == 6 or number == 8:\n",
    "    print(\"This number is even and small\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 8\n",
    "if number > 1 and not number > 1:\n",
    "    print(\"This will never happen\")\n",
    "else:\n",
    "    print(\"This will always happen\")\n",
    "# Do you know why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 1\n",
    "if number > 1 or not number >= 1:\n",
    "    print(\"This will always happen\")\n",
    "else:\n",
    "    print(\"This will never happen\")\n",
    "# Do you know why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, the rules are:\n",
    "\n",
    "- **and** needs both sides to be True.\n",
    "- **or** needs one or more sides to be True.\n",
    "- **not** only looks at the right side and changes it from True to False, or from False to True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"How does AND work?\")\n",
    "print(\"True and True makes:\", True and True)\n",
    "print(\"True and False makes:\", True and False)\n",
    "print(\"False and True makes:\", False and True)\n",
    "print(\"False and False makes:\", False and False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"How does OR work?\")\n",
    "print(\"True or True makes:\", True or True)\n",
    "print(\"True or False makes:\", True or False)\n",
    "print(\"False or True makes:\", False or True)\n",
    "print(\"False or False makes:\", False or False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"How does NOT work?\")\n",
    "print(\"not True makes:\", not True)\n",
    "print(\"not False makes:\", not False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ⭐️⭐️⭐️💥 What you learned in this session: Three stars and a wish."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In your own words** write in the Markdown cell below:\n",
    "\n",
    "- 3 things you would like to remember from this notebook.\n",
    "- 1 thing you wish to understand better in the future or a question you'd like to ask."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Add your reflections here.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ⛏ Bonus Minitask: Model a real-life scenario with conditions and logic.\n",
    "\n",
    "- Pick a real-life scenario, everyday example of performing a task (see examples below).\n",
    "- Use 'if-elif-else' where appropriate with 'and/or/not' operators and help the user to find out if they can make a cup of tea, or if they still need something. \n",
    "\n",
    "Here are some other examples you could choose to build:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example: \n",
    "# Bus-pass app: Write code that checks if you took your bus pass and if you can buy a bus ticket.\n",
    "# If you can buy a ticket, subtract ticket price from your bus pass.\n",
    "\n",
    "credit_on_your_bus_card = 7.80\n",
    "price_of_a_ticket = 2.20\n",
    "\n",
    "# When you run this cell, your 'credit_on_your_bus_card' will be reset to it's original value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here is a simple solution:\n",
    "\n",
    "do_you_have_your_bus_pass = True # you can change this\n",
    "\n",
    "if do_you_have_your_bus_pass == False:\n",
    "    print(\"Oh no! You forgot your bus pass :(\")\n",
    "elif credit_on_your_bus_card <  price_of_a_ticket:\n",
    "    print(\"Not enough for the ticket!\")\n",
    "else:\n",
    "    credit_on_your_bus_card = round(credit_on_your_bus_card - price_of_a_ticket,2) \n",
    "    print(\"Ticket bought\")\n",
    "\n",
    "print(\"Remaining Credit =\", credit_on_your_bus_card)\n",
    "\n",
    "# When you run this cell a few times, you will see it work differently each time.\n",
    "# As in: each time you run this cell, a new ticket will be bought, untill you're out of money on the bus card.\n",
    "# Try running this cell many times.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here is the same solution as above, but with more 'user interface'.\n",
    "# it means you ask your user for input and tell your user what's going on\n",
    "\n",
    "credit_on_your_bus_card = 7.80\n",
    "user_input = input(\"Did you take your buspass? (type Y or N)\")\n",
    "\n",
    "if (user_input == \"Y\"):\n",
    "    do_you_have_your_bus_pass = True\n",
    "elif (user_input == \"N\"):\n",
    "    do_you_have_your_bus_pass = False\n",
    "else:\n",
    "    print(\"You need to type Y or N. You typed something else. You typed:\", user_input)\n",
    "    print(\"... so I'll assume you do not have your bus pass\")\n",
    "    do_you_have_your_bus_pass = False\n",
    "# run this, then run next cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if do_you_have_your_bus_pass == False:\n",
    "    print(\"Oh no! You forgot your bus pass :(\")\n",
    "elif credit_on_your_bus_card <  price_of_a_ticket:\n",
    "    print(\"Oh no! You have only\",credit_on_your_bus_card,\"on your bus pass.\")\n",
    "    money_you_are_missing = round(price_of_a_ticket - credit_on_your_bus_card,2)\n",
    "    # Note: round(some_number,2) rounds to 2 decimal places. \n",
    "    print(\"That's not enough for a ticket. You're missing\", money_you_are_missing)\n",
    "else:\n",
    "    print(\"Subtracting bus fee from your bus pass...\")\n",
    "    credit_on_your_bus_card = round(credit_on_your_bus_card - price_of_a_ticket,2) \n",
    "    print(\"Success! You can get on the bus, enjoy!\")\n",
    "    print(\"Remaining Credit =\", credit_on_your_bus_card)\n",
    "    \n",
    "# remember: to reset amount of money on the buspass run the top cell again,\n",
    "#  the one that says: credit_on_your_bus_card = 7.80"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Now your turn: choose a scenario and write code that solves it with code:**\n",
    "\n",
    "- Maps app: create variables describe your speed of walking, cycling and driving a car (eg. in miles per hour). \n",
    "Then write a program that asks the user how far they want to go (eg. 30 miles), and then asks them by what means of transport (e.g walk/bus/car). \n",
    "Finally tell them how long it will take to get to the destination by that mode of transport.\n",
    "- Stock Market: write a program that asks the user for the price of a stock item when they buy it, price when they sell it, and the number of the shares they sold. \n",
    "Show a different message depending if they made money or lost money, and tell them exactly how much.\n",
    "\n",
    "See example above\n",
    "\n",
    "Remember to save your progress every now and then ('File > Save', or a keyboard shortcut 'command/ctrl S', or click the small 'Disk' icon in the top left of your Notebook). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here you can write your code (to add more cells, use the '+' symbol in the top menu bar of your Notebook)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}