Session 1a - Write and Run.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Session 1a: Write and Run."
   ]
  },
  {
   "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",
    "- How code is executed by Python.\n",
    "- What variables are.\n",
    "- That there are variable types (string, int, float, bool), and how they impact how code behaves, e.g. 20 + 20 is different from \"20\"+\"20\".\n",
    "- How to change variable types with *casting*.\n",
    "- How to ask users for some input.\n",
    "\n",
    "\n",
    "### 🔜 SPOILER ALERT:\n",
    "\n",
    "You will also understand these lines of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remember - run all code cells from top to bottom as you go through the notebook. (Shift + Enter)\n",
    "# Lines starting with '#' are just comments, they output nothing when run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Running code and printing things.\n",
    "# Prints appear immediately under the cell.\n",
    "\n",
    "print(3 + 1) \n",
    "print(3 + 2) \n",
    "print(3 + 3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# but output/return of ONLY THE LAST LINE of code appears in the Out[ ]: section below your print.\n",
    "# That's why printing is a nice way to know what's going on.\n",
    "\n",
    "2 + 1\n",
    "2 + 2\n",
    "2 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assigning values to variables:\n",
    "\n",
    "name = \"Fiona\"\n",
    "surname = \"McDougal\"\n",
    "full_name = name + surname\n",
    "print(name, surname, full_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distance = 10 + 10 + 1\n",
    "distance = distance + 10\n",
    "print(distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variables vs names of variables \n",
    "print(\"Banana!\") # string!\n",
    "print(\"name\") # string!\n",
    "print(name) # variable! notice lack of brackets, and colour difference!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"We stored a string\", name, \"in a variable called 'name'\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Types:\n",
    "\n",
    "print(type(\"Banana\")) # \"string\" is a short name for \"a string of characters\" i.e. a sentence\n",
    "print(type(1246))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Types determine the meaning of operations.\n",
    "\n",
    "print(\"20\"+\"20\")\n",
    "print(20+20)\n",
    "print(\"20\"+20) # This will error out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variables can be cast (changed/forced) into other variables.\n",
    "\n",
    "print(int(\"20\")+20) # Both as integer.\n",
    "print(\"20\"+str(20)) # Both as string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 🎯 End of learning objectives 🎯"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lines of code are always executed from top to bottom."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have a look at this very simple computer program which will print (display on the screen) some letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To run this block of code, click it, then press Shift + Enter. \n",
    "# Below you will see the 'output' - the effect of your program being run.\n",
    "# Oh also, a line of code starting with a # like this one is a comment, and will be ignored by Python, yay!\n",
    "\n",
    "print(\"a\")\n",
    "print(\"b\")\n",
    "print(\"ccc\")\n",
    "print(\"d\" + \"d\")\n",
    "print(\"e\",\"e\",\"e\")\n",
    "\n",
    "# Compare the printed output below with the code. Can you see exactly which line caused which output?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notice that Shift + Enter automatically took you to the next cell.\n",
    "# So keep holding shift and just click Enter again.\n",
    "\n",
    "print(10)\n",
    "print(11)\n",
    "print(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You probably see letters a,b,c,d,e printed one under another. Notice they appeared in the same order as specified in our code (in the ```print()``` statements).\n",
    "\n",
    "**CODE IS RUN FROM TOP TO BOTTOM** - things (calculations, prints, etc.) will happen from the top one to the bottom one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💥 **JARGON BUSTERS: (example)** - in many places in these notes you will find new concepts explained in plain language, see examples below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**💥 A PROGRAM / CODE**: a list of commands (things to do) for the computer. Always read from top to bottom.\n",
    "\n",
    "**💥 PRINT(\"something\")**: a command instructing the computer to display \"something\" on the screen. \n",
    "    \n",
    "- For example a line of code ```print(\"banana\")``` tells the computer to display the word ```\"banana\"``` on the screen.\n",
    "    \n",
    "**💥 RUNNING / EXECUTING a program**: a process in which your code is interpreted (understood), and the commands you wrote are run (executed, performed, done).\n",
    "    \n",
    "- For example when the command ```print(2 + 2)``` is executed, you will see ```4``` on the screen, not ```2 + 2``` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables: Places to store values for later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**💥 VARIABLES**: Storage places in computer memory where you can store information. \n",
    "You will write code to create your own variables. \n",
    "Variables are like labeled boxes where you can store things for later, or like parking spots where you can put something temporarily at any point and take it back later. \n",
    "Each variable has a 'Name', 'Type' and 'Value'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this code, and you should see the words Edinburgh and Meadows appear below. \n",
    "\n",
    "city = \"Edinburgh\"\n",
    "place = \"Meadows\"\n",
    "\n",
    "print(\"city\")\n",
    "print(city)\n",
    "print(place)\n",
    "print(place, \"is in\", city)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The way to understand the above example ```city = \"Edinburgh\"``` ...\n",
    "\n",
    "is to see it as ```variable_name = variable_value```\n",
    "\n",
    "- City is the variable's **NAME**\n",
    "- \"Edinburgh\" is the variable's **VALUE**\n",
    "- String is the variable's **TYPE** (String stands for a \"String of characters\" and is another way to say \"text\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**💥 NAMES**: You can call variables whatever you want, but you cannot use spaces, so use underscores instead, like ```student_name, annual_total```.\n",
    "\n",
    "You **ABSOLUTELY** want to avoid names that are meaningless like ```x```, ```thing```, ```foo``` or even ```result```.\n",
    "\n",
    "```\"When you write Good Code - computers can understand what you mean. When the code is Even Better - other humans can understand what you mean. But Great Code is one that you yourself will understand in a few months\".```\n",
    "\n",
    "So use good variable names and #comments for your colleagues but also for yourself :)\n",
    "\n",
    "**💥 PRINTING variable values**: At any point to have a look at what is stored in a variable you can print (show, display) it to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Banana\")\n",
    "print(place)\n",
    "\n",
    "# Print can also take many variables separated by comma.\n",
    "\n",
    "print(place, city)\n",
    "\n",
    "# You can even add strings in there.\n",
    "\n",
    "print(\"I'm at the\", place, \"in\", city)\n",
    "\n",
    "# Notice that print will add spaces between words all by itself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **💥 ASSIGNMENT**: you know usage of an equals sign `=` from maths as a way to say that two things are the same. Like 2+2=4. \n",
    " In programming = means something new. It is called an assignment operator. \n",
    " It takes what's on the right of the = and assigns it (stores it) in the variable on the left opf the = sign.\n",
    " \n",
    "An assignment looks like this: \n",
    "\n",
    "```variable_to_put_value_in = the_new_value```\n",
    "\n",
    "You can imagine assignment as an arrow from right to left, think of it as: \n",
    "\n",
    "```destination = value```\n",
    "\n",
    "Or imagine ```=``` as an arrow: \n",
    "\n",
    "```destination <===== value```\n",
    "\n",
    "The right hand side of ```=``` can be a value (eg. ```34```), variable (eg. ```speed```) or a calculation (eg.```2+3```)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Minitask: Can you guess what will be printed before you run this cell?\n",
    "\n",
    "value_1 = 3\n",
    "value_2 = 2 + 2\n",
    "value_3 = 3 * 2 + 10\n",
    "value_4 = value_1 + value_2\n",
    "value_5 = value_4 + 1\n",
    "\n",
    "# Notice: \n",
    "# - Left always has just one variable, where the result will be stored.\n",
    "# - Right can have a mixture of values and variables.\n",
    "\n",
    "print(value_1)\n",
    "print(value_2)\n",
    "print(value_3)\n",
    "print(value_4)\n",
    "print(value_5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value stored in a variable can change (indeed the word **'variable' means changeable**). \n",
    "And we can assign new values to the variable which holds something the same way as if we put something in the variable when it had nothing in it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 43\n",
    "print(count)\n",
    "count = 44\n",
    "print(count)\n",
    "count = 45\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TRICKY BIT: right happens first**: Code on the right of ```=``` always happens first because you need to know what the result or the calculation will be (right hand side), before you can store in a variable (left hand side).\n",
    "\n",
    "This is important, because you can use a variable to calculate its own new value. So the code: \n",
    "\n",
    "```count = count + 1``` sort of means ```new_count = old_count + 1```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 1\n",
    "print(count)\n",
    "count = count + 5 # When this happens, it's basically count = 1 + 5.\n",
    "print(count)\n",
    "count = count + 20 # When this happens, it's basically count = 6 + 20.\n",
    "print(count)\n",
    "\n",
    "# Right hand side happens first, and then we do the assignment second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "starting_number = 7\n",
    "print(starting_number)\n",
    "starting_number = starting_number + 1\n",
    "starting_number = starting_number + 1\n",
    "starting_number = starting_number + 1\n",
    "print(starting_number)\n",
    "\n",
    "# Can you explain what numbers will be printed and why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: that the above can be represented with \"Syntactic Sugar\" (syntax that makes our lives sweeter)\n",
    "\n",
    "starting_number = 7\n",
    "print(starting_number)\n",
    "starting_number += 1\n",
    "starting_number += 1\n",
    "starting_number += 1\n",
    "print(starting_number)\n",
    "\n",
    "# Can you explain what numbers will be printed and why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variable Types:\n",
    "Variables can store many different types of data in them. \n",
    "Simplest ones are numbers (int) and words (string). \n",
    "Sometimes it's important to distinguish between one and the other. \n",
    "Notice that whole and decimal numbers are of a different type.\n",
    "\n",
    "**int**: whole numbers like `43`\n",
    "\n",
    "**float**: fractions like `6.23`\n",
    "\n",
    "**string**: words like `\"Banana\"`\n",
    "\n",
    "**bool**: logic values like `True` or `False`\n",
    "\n",
    "If you want to find out what type of data is stored in a variable, you can ask Python by using `type(your_variable)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Matilda\"\n",
    "surname = \"Tolkien\"\n",
    "points = 72\n",
    "accuracy = 0.82\n",
    "registered = True\n",
    "present = False\n",
    "\n",
    "# Let's print values of these variables.\n",
    "\n",
    "print(name, surname, points, accuracy, registered, present)\n",
    "\n",
    "# Let's print types of these variables.\n",
    "\n",
    "print(type(name), type(surname), type(points), type(accuracy), type(registered), type(present))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operations (like adding) can mean something else depending on the data type.\n",
    "\n",
    "You can add and subtract values from each other, and Python will do its best to understand what you mean. \n",
    "That's because often the same operation might mean two different things depending on the context. \n",
    "For example, we often mean something slightly different when we talk about ADDING two numbers and when we talk about ADDING two words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What will be the result of using + below.\n",
    "\n",
    "print(2 + 2) # ADDING numbers.\n",
    "print(\"2\" + \"2\") # ADDING strings.\n",
    "\n",
    "# Notice we're using the same + operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"twenty\" + \"nine\")\n",
    "print( 20 + 9 )\n",
    "print( \"20\" + \"9\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, Python first checks what TYPE of data the operation will be performed on, and then performs what it understands by that operation in that context. Adding words combines them together into a longer word, but adding numbers uses maths to make a different number.\n",
    "\n",
    "**Weakly Typed Language**: In Python (unlike in many other languages) it is not required to specify what type of data will be kept in a variable. \n",
    "We call languages like that 'weakly-typed languages'. So you could store a number in a variable, and then change your mind and store a word in there. \n",
    "Note that this is a bad idea, because it causes confusion (for yourself and others) so please never do that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# BAD practice: Overwriting value of a variable with a value of another type is allowed (will not return an error).\n",
    "\n",
    "score = \"Fifty Five\"\n",
    "score = 55\n",
    "score = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warning: With great power comes great responsibility** : It is your job as a programmer to make sure that a particular operation makes sense. \n",
    "For example, try to run the below code and read the error. Would you know how to fix this code? Keep reading to find out more:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(\"My age is \" + 23)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing the type: 'Casting'.\n",
    "\n",
    "Sometimes you want to change what TYPE a particular piece of data is. \n",
    "You might know this from Excel, where the same value can be a date, number or a word, and will be behave differently.\n",
    "\n",
    "Forcing a variable to be of certain type is called **casting**. \n",
    "Think of a cast that we put on someone's arm when it's broken - it's a piece of plaster that will make sure that the arm stays in a certain position. \n",
    "\n",
    "There are many ways to change the type of some data. E.g. in the 'print'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( \"My age is \" + 23)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You probably just want to treat the number ```23``` as if it was a string ```\"23\"``` and join it with the ```\"My age is \"``` string. \n",
    "This way you would be connecting two string.\n",
    "\n",
    "```type( some_value )``` is a way to ask Python 'what is the type of this variable/value'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change int to string: str(my_number).\n",
    "\n",
    "type(23) # 23 is a integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(\"23\")  # \"23\" is a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change string to int: int(my_string).\n",
    "\n",
    "type(\"2019\")  # \"2019\" is a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type( int(\"2019\") ) # 2019 is a int."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also other operators like `float(my_variable)`, `bool(my_variable)`.\n",
    "\n",
    "TRICKY BIT: Notice that not everything can be changed into everything. \n",
    "We will cover anticipating errors (Error Handling) later in the course, for now we just going to have to trust the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type( int(\"banana\") )  # How would you represent a banana as a number?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, it is ok to be over-protective, and no bad things will happen if we try to turn a number into a number again.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1999 forced to be a number, so it is still 1999.\n",
    "\n",
    "int(1999)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(\"banana\") # Same, \"banana\" forced to be a string is still \"banana\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Asking user to type some input.\n",
    "\n",
    "Asking for input is a 'jealous'/'possessive' operation - it will freeze your Notebook (your Notebook will be not responsive and will not 'work') until the question is answered! \n",
    "\n",
    "Running code like this will ask for user input underneath the cell:\n",
    "\n",
    "```answer = input(\"What is your name?\")```\n",
    "\n",
    "But it will also wait for the answer UNTIL YOU ANSWER IT. The notebook will appear 'frozen'.\n",
    "\n",
    "### What are the symptoms of a frozen Notebook? \n",
    "\n",
    "- In [ * ] on the left of the cells.\n",
    "- ⏳ hourglass icon in your browser tab, instead of 📘 notebook symbol.\n",
    "- Other cells do not run, instead they also get a '*' symbol.\n",
    "\n",
    "### What to do? \n",
    "\n",
    "- Answer the question that the notebook is waiting for, it will immediately unfeeze.\n",
    "- If you cannot find which cell is waiting for your input, you can always 'restart kernel' of your server. \n",
    "\n",
    "### Restarting the Kernel:\n",
    "\n",
    "It is basically like switching your computer off and on again. (in the top menu Kernel > Restart Kernel). You will NOT lose any of your work, but all variables will be forgotten, so you might need to re-run some cells. You'll be fine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of user input.\n",
    "\n",
    "age = input(\"What is your age?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: That what user typed is ALWAYS a string (a word) so to use it as a number you need to cast it into a number.\n",
    "\n",
    "age = input(\"What is your age?\")\n",
    "print(\"last year you were \", age -1 )\n",
    "\n",
    "# This will not work, because age is a string.\n",
    "# i.e. contains a word \"25\" not a number 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# But casting will solve your problem.\n",
    "\n",
    "answer =  input(\"What is your age?\") \n",
    "age = int(answer)\n",
    "print(\"Last year you were\", age - 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ⭐️⭐️⭐️💥 What you have 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: Create variables and perform calculations on them.\n",
    "\n",
    "In this exercise you will create some variables, store values in them. And then use those values to calculate things. First have a look at this simple example of a warehouse management system:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example: \n",
    "\n",
    "cookies_in_a_pack = 8\n",
    "packs_in_a_big_box = 24\n",
    "big_boxes_in_the_truck = 60\n",
    "print(\"cookies in a pack:\", cookies_in_a_pack)\n",
    "print(\"cookies in a big box:\", cookies_in_a_pack * packs_in_a_big_box)\n",
    "print(\"cookies in a truck\", cookies_in_a_pack * packs_in_a_big_box * big_boxes_in_the_truck)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You could also solve it in a cleaner way using variables:\n",
    "cookies_in_big_box = cookies_in_a_pack * packs_in_a_big_box\n",
    "cookies_in_truck = cookies_in_big_box * big_boxes_in_the_truck\n",
    "\n",
    "print() # This line will print an empty like, so that things are easier to read.\n",
    "print(\"cookies in a pack:\", cookies_in_a_pack)\n",
    "print(\"cookies in a big box:\", cookies_in_big_box)\n",
    "print(\"cookies in a truck\", cookies_in_truck)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First set of tasks:\n",
    "\n",
    "Look at the code below. It defines a number of variables, but there are missing parts of code. Try to complete them and run the cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This creates a set of variables:\n",
    "days_of_employment = 12\n",
    "salary_per_hour = 25\n",
    "working_hours_in_a_day = 8\n",
    "number_of_workers = 3\n",
    "budget = 10000\n",
    "\n",
    "# Below write some code that will print following information.\n",
    "# (Don't do the math by yourself! Let Python do it!)\n",
    "# For extra learning: create your own variables, like in the second example above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What is the salary per day? \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What is a salary for each worker, for the whole period of employment?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What is the total spend for the whole project (all workers, all days)?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given the budget, how much money is still left?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Another set of tasks:\n",
    "\n",
    "Repeat the process above but for a scenario you come up with. \n",
    "\n",
    "Here is one suggestion: \n",
    "\n",
    "How about a **\"🍋🥤lemonade stand\" simulation🥤🍋**, where someone makes lemonade from sugar, water and lemons?  Your variables could be: how many units of lemons, sugar and water are in the recipe for 1 liter of lemonade? What is the price for a unit of lemons, sugar and water? How much do you charge per liter? So how much did you earn per liter (given that you had to pay for ingredients)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here you can write your code (to add more cells, use '+' symbol in top menu)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Another set of tasks:\n",
    "\n",
    "- Create variables for number of days in a week (called eg. days_in_in_a_week), weeks in a month (just round it to 4, no need to be super accurate), months in a year. Then calculate and store in a variable the number of days in a year. Print that variable.\n",
    "- This is not very accurate, because some months are longer than others. How would you fix it? For example you could use the actual number of weeks in a month (4.35) or use the fact that a year usually has exactly 52 weeks.\n",
    "\n",
    "More Advanced:\n",
    "\n",
    "- Do the same for number of seconds, minutes and hours in a day. How many seconds are there in a year?\n",
    "\n",
    "Even More Advanced:\n",
    "\n",
    "- Create a simple program that asks the user about their age and tells them how many seconds that is (see below note about asking user for input) (NOTE: remember that what user types is always a string, so you'll need to 'cast' it into a number).\n",
    "- Add anything else that comes to your mind and would be fun.\n",
    "\n",
    "Remember to every now and then save your progress (File > Save, or a keyboard shortcut, or by clicking the 'Disk' icon top left corner of your Notebook.) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try to solve the task here (to add more cells, use '+' symbol in top menu)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary style='color:blue'>HINT 1: Days in a year: CLICK HERE TO SEE THE ANSWER. BUT REALLY TRY TO DO IT YOURSELF FIRST!</summary>\n",
    "\n",
    "    ### BEGIN SOLUTION\n",
    "    days_in_week = 7\n",
    "    weeks_in_month = 4.35\n",
    "    months_in_year = 12\n",
    "\n",
    "    days_in_year = days_in_week * weeks_in_month * months_in_year\n",
    "    print(\"There are\", days_in_year, \"days in a year\")\n",
    "    ### END SOLUTION\n",
    "    \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary style='color:blue'>HINT 2: Seconds in a day: CLICK HERE TO SEE THE ANSWER. BUT REALLY TRY TO DO IT YOURSELF FIRST!</summary>\n",
    "\n",
    "    ### BEGIN SOLUTION\n",
    "    seconds_in_minute = 60\n",
    "    minutes_in_hour = 60\n",
    "    hour_in_day = 24\n",
    "\n",
    "    seconds_in_day = seconds_in_minute * minutes_in_hour * hour_in_day\n",
    "    print(\"There are\", seconds_in_day, \"seconds in a day\")\n",
    "    ### END SOLUTION\n",
    "    \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary style='color:blue'>HINT 3: User's age in seconds: CLICK HERE TO SEE THE ANSWER. BUT REALLY TRY TO DO IT YOURSELF FIRST!</summary>\n",
    "\n",
    "    ### BEGIN SOLUTION\n",
    "    seconds_in_a_year = seconds_in_day * days_in_year\n",
    "    user_age_string = input(\"How old are you?\")\n",
    "    user_age_number = int(user_age_string)\n",
    "    user_age_in_seconds = user_age_number * seconds_in_a_year\n",
    "    print(\"You are over\",user_age_in_seconds,\"seconds old\")\n",
    "    # try rounding the number with: round(some_number)\n",
    "    ### END SOLUTION\n",
    "    \n",
    "</details>"
   ]
  }
 ],
 "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}