Session 2 - Functions = superpowers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Session 2: Functions are your superpowers."
   ]
  },
  {
   "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 to understand the order of executing code.\n",
    "- Functions are shortcuts to repeat parts of your code easily.\n",
    "- Functions can also accept variables, so you can repeat code that is slightly different each time.\n",
    "- Functions can also return what they calculated, so that you can 'outsource' some operations to a function. \n",
    "\n",
    "This notebook covers the full session for this week (instead of two separate notebooks) and as such is quite long and intense. Take breaks, drink water, go slowly. You can do this! At the end you will find plenty of exercises to practice.\n",
    "\n",
    "### 🔜 SPOILER ALERT:\n",
    "\n",
    "You will also understand these lines of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function definitions:\n",
    "\n",
    "def are_any_of_these_names_the_same(name_1, name_2, name_3):\n",
    "    result = (name_1 == name_2) or (name_2 == name_3) or (name_3 == name_1)\n",
    "    return result # This is returned to whoever called this function.\n",
    "\n",
    "# Note: Whenever you run a cell with a function definition, you \"load\" that function into memory.\n",
    "# There's no need to run it a lot, just once is enough.\n",
    "# And if you change the function you will want to run it again to \"re-load\" it into the momory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calling functions - result will be displayed underneath the cell. \n",
    "# You can only return one thing from each cell. It will usually be the result of the last line of code.\n",
    "are_any_of_these_names_the_same(\"Billie\", \"fiona\", \"fiona\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can call the funciton multiple times, giving it differrent input variables.\n",
    "\n",
    "are_any_of_these_names_the_same(\"Billie\", \"fiona\", \"Jin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and again!\n",
    "are_any_of_these_names_the_same(\"Billie\", \"Billie\", \"Jin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Printing function results. \n",
    "# You can run a function, store what it returns in a variable. \n",
    "# And then print that variable\n",
    "\n",
    "are_they_similar = are_any_of_these_names_the_same(\"Max\", \"fiona\", \"Jin\")\n",
    "print(are_they_similar)\n",
    "\n",
    "# Or you can put the function call directly into the print, to have a shorter (folded, nested) version.\n",
    "\n",
    "print( are_any_of_these_names_the_same(\"Jin\", \"fiona\", \"Jin\") )\n",
    "\n",
    "# Both above solutions do the same thing and are just as goood."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 🎯 End of learning objectives 🎯"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's try imagining the ORDER in which code is executed, in cycles or steps.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Think about the order in which a computer needs to find answers to some questions.\n",
    "# In order to then seek answers to other questions\n",
    "\n",
    "# E.g. you need to know what int(\"20\") is before you can add it to 20.\n",
    "# And only once you add them you can print the result.\n",
    "\n",
    "print(int(\"20\") + 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Same here. As a human, which parts would you have to solve first?\n",
    "# try to solve it before you run the code. What's the result you expect?\n",
    "\n",
    "print((20 + 50) / 7 == (1+4) * (9-7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imagine that in each cycle one operation is REPLACED with the result of that operation.\n",
    "\n",
    "### Code is always run from the MOST INSIDE operation: think from the smallest Russian Doll outwards, or beginning from the stone inside an avocado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You will learn about functions soon, but notice what this code does.\n",
    "# You always evaluate the code from the current MOST INSIDE operation.\n",
    "# Evaluated code is sort-of replaced with its result.\n",
    "\n",
    "print(\"year \" + str(int(\"19\"+\"99\") + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In short, the code is run from the inside to the outside.\n",
    "# And commands are basically REPLACED with their result.\n",
    "# Below is an attempt on simulating, one step at a time, how the computer thinks:\n",
    "\n",
    "print(\"year \" +  str(int(\"19\"+\"99\") + 1) )\n",
    "print(\"year \" +  str(int(\"1999\"   ) + 1) )\n",
    "print(\"year \" +  str(1999           + 1) )\n",
    "print(\"year \" +  str(2000              ) )\n",
    "print(\"year \" +  \"2000\"                  )\n",
    "print(\"year 2000\"                        )\n",
    "\"year 2000\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# But if the code was like this, why is the result different? \n",
    "# Try to figure it out by yourself before running the code!\n",
    "\n",
    "print(\"year \" + str(int(\"19\") + int(\"99\") + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can you break it down below, into steps like we did above?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions: The most important tool of programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**FUNCTION**: A piece of code that we want to reuse later. \n",
    "We give each function a short name, so that we can easily run them (make them happen). \n",
    "There is a difference between DEFINING a function - specifying which lines of code we want to reuse, and CALLING a function - making these lines of code happen.\n",
    "\n",
    "At the simplest level, a function is a shortcut to some code we wrote before, that we want to use later on.\n",
    "Like using a key that opens a toolbox, to access tools that you've previously build. \n",
    "\n",
    "**DEFINING A FUNCTION**: To define, create or specify a function we mark some lines of code and give it a name. \n",
    "Note that this will not run the lines of code, because when we define a function, we specify that we would like to execute it later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function:\n",
    "\n",
    "def my_function_name():\n",
    "    print(\"Function is running!\")\n",
    "    print(\"Things are happening!\")\n",
    "\n",
    "    # Some code we will reuse later.\n",
    "    # Note: this code is not executed yet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**RUNNING (or CALLING) A FUNCTION**: Once a function is defined, we can call (run, evaluate) that function by writing its name followed by a (). That will cause all the lines of code inside of a function to be executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call a function:\n",
    "\n",
    "my_function_name() # Only now code inside of the function will be executed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function:\n",
    "\n",
    "def make_some_tea(): \n",
    "    print(\"Boil Water\")\n",
    "    print(\"Put a teabag in a mug\")\n",
    "    print(\"Put water in a mug\")\n",
    "    print(\"...wait\")\n",
    "    print()\n",
    "    \n",
    "# Calling a function:\n",
    "# We can do it multiple times, if we want to!\n",
    "\n",
    "make_some_tea()\n",
    "make_some_tea()\n",
    "make_some_tea()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once a function is defined it can be run many times.\n",
    "\n",
    "One way to understand the difference between defining a function and calling it is:\n",
    "\n",
    "- Defining a function is like writing a recipe for a cake: You specify all the ingredients, steps, tools you will need. But you do not actually bake the cake yet i.e the lines of code are not actually executed/run.\n",
    "\n",
    "- Running a function is like using the recipe to bake the cake: You can bake a cake from the same recipe many times. You can even pass in some unique attributes to each cake, like different toppings or flavours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def start_a_conversation():\n",
    "    print(\"Hello!\")\n",
    "    print(\"How are you doing?\")\n",
    "    print(\"Have you seen my keys?\")\n",
    "    print()\n",
    "\n",
    "# Notice that when you run this code, nothing happens.\n",
    "# You defined a function, but you did not call it yet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def start_a_conversation():\n",
    "    print(\"Hello!\")\n",
    "    print(\"How are you doing?\")\n",
    "    print(\"Have you seen my keys?\")\n",
    "    print()\n",
    "\n",
    "# You can call the function many times, reusing the code, and needing to type less.\n",
    "\n",
    "start_a_conversation()\n",
    "start_a_conversation()\n",
    "start_a_conversation()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Refactoring Code 2: \"DRY\" code means \"Don't Repeat Yourself\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you write code your ambition is to type as little as possible. That means that when you see some code repeated more than 2-3 times, you should try to OPTIMISE it by writing it in a simpler, more efficient form.\n",
    "\n",
    "From now on you will notice that some code you write is just a repetition. And sometimes (within reason!) you might want to shorten in. See example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basic functions are easy to use when you would like to repeat something many times.\n",
    "# For example this to repeat a greeting 4 times. \n",
    "\n",
    "# NOT DRY:\n",
    "\n",
    "print(\"Friend! How are you? It is great to see you again!\")\n",
    "print(\"Friend! How are you? It is great to see you again!\")\n",
    "print(\"Friend! How are you? It is great to see you again!\")\n",
    "print(\"Friend! How are you? It is great to see you again!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You could simplify/organise it better, like this:\n",
    "\n",
    "# DRY:\n",
    "\n",
    "def greet():\n",
    "    print(\"Friend! How are you? It is great to see you again!\")\n",
    "    \n",
    "greet()\n",
    "greet()\n",
    "greet()\n",
    "greet()\n",
    "\n",
    "# Your code is cleaner, but the greatest strength shows us when you need to change something in your code..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**DRY CODE IS EASIER TO MAINTAIN (to edit later)**: The more dry your code is, the less work it is to change it later.\n",
    "\n",
    "Imagine that in the above example you want to change a single word in your greeting to ``` It is FANTASTIC to see you again!```. In the not dry example you would need to change it in 4 places, in the dry example above you only need to change it in one place. This already saves you some time, right? Now imagine the first example had 100 repeated lines, or 1000 repeated lines!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet():\n",
    "    print(\"PAL! How are you? It is FANTASTIC to see you again!\") \n",
    "    # We only had to change this one line of code, not 4 lines.\n",
    "    \n",
    "greet()\n",
    "greet()\n",
    "greet()\n",
    "greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Passing arguments (variables) into functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But functions can do so much more than that! Imagine that you wanted to do something more complicated.\n",
    "\n",
    "Let's imagine that we want to make the below code DRY. In the below example the lines of code are very similar but are NOT IDENTICAL. That means that we can't just extract them into a function like we did above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(\"Ingrid! How are you? It is great to see you again!\")\n",
    "print(\"Shri! How are you? It is great to see you again!\")\n",
    "print(\"Ainsley! How are you? It is great to see you again!\")\n",
    "print(\"Eli! How are you? It is great to see you again!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**REUSING CODE**: To reuse or repeat some functionality we need to identify what parts of it change, and what parts of it don't change. \n",
    "Most of the time when creating a function the challange is to identify which parts of your code are REUSED (they do not change) and which are VARIABLE (they change).\n",
    "\n",
    "You probably see that most of the code above is repeated, but in each line, there is a small element that is different.\n",
    "\n",
    "In the above example this part IS NOT CHANGING: ```print(\"###! How are you? It is great to see you again!\")``` while the name of our friend IS CHANGING: ```Ingrid Shri Ainsley Eli```.\n",
    "\n",
    "Imagine rewriting above code with friend names as variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This produces the same outcome as above code. Have an exact look at what is happening there.\n",
    "\n",
    "name = \"Ingrid\"\n",
    "print(name + \"! How are you? It is great to see you again!\") # This is repeated.\n",
    "name = \"Shri\"\n",
    "print(name + \"! How are you? It is great to see you again!\") # This is repeated.\n",
    "name = \"Ainsley\"\n",
    "print(name + \"! How are you? It is great to see you again!\") # This is repeated.\n",
    "name = \"Eli\"\n",
    "print(name + \"! How are you? It is great to see you again!\") # This is repeated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do you see how much of the code can now be reused? Now every second line is identical.\n",
    "\n",
    "**Functions become an increadibly powerful concept when we tell them to not only repeat some code, but to repeat it with small differences.**\n",
    "\n",
    "For example: We can create a function that helps us to reuse some parts of the above code. \n",
    "Like when we used 'name', as a changeable piece of code, we will pass a variable ('name_of_a_friend') into our function. \n",
    "Now we can control the changes to the outcome each time we call the function, without so many repeated parts of code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " # name or name_of_a_friend or whatever you call it, is the changing (aka. 'variable') part from above.\n",
    "    \n",
    "def greet(name):\n",
    "    print(name + \"! How are you? It is great to see you again!\") # This is the repeated bit, do you see?\n",
    "    # This is the repeated part from above.\n",
    "\n",
    "greet(\"Ingrid\")\n",
    "greet(\"Shri\")\n",
    "greet(\"Ainsley\")\n",
    "greet(\"Eli\")\n",
    "\n",
    "# When we call a function that takes some variables, we can reuse the code we specified above.\n",
    "# But we can also do it in a given context - with some elements changing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another simple example:\n",
    "\n",
    "def say_it_twice(something):\n",
    "    print(something + something)\n",
    "    print(\"Yay! I said it twice!\")\n",
    "\n",
    "say_it_twice(\"Banana\")\n",
    "say_it_twice(\"Apples\")\n",
    "say_it_twice(\"Pears\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**FUNCTION PARAMETERS**: Variables (things that change) that we pass into a function are called function parameters (things that you adjust). Parameters are something we do all the time in our daily life, whenever we repeat a familiar activity with some small element of it changing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_time(time):\n",
    "    print(\"The time is \"+ time)\n",
    "\n",
    "read_time(\"14:30\")\n",
    "read_time(\"20:05\")\n",
    "read_time(\"23:33\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes **Parameters** are also called **Attributes**.\n",
    "\n",
    "Sometimes **Functions** are also called **Methods**.\n",
    "\n",
    "**But (don't tell anyone ;) ) it REALLY does not matter how you call them.** Even people with years of experience confuse those two terms, so I would not bother to clarify the exact differences. \n",
    "It's a bit like **folder** and **directory** on your computer. \n",
    "There might be a difference between them, but people use them as synonyms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functions can have more than one parameter. \n",
    "# (We're back to our example above. Notice that attribute names can be called whatever you want!)\n",
    "\n",
    "def greet(name_of_a_friend, mood):\n",
    "    print(name_of_a_friend + \"! How are you? It is \" + mood + \" to see you again!\")\n",
    "\n",
    "greet(\"Ingrid\", \"great\")\n",
    "greet(\"Shri\", \"fantastic\")\n",
    "greet(\"Ainsley\", \"glorious\")\n",
    "greet(\"Eli\", \"splendid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(name_of_a_friend, time_of_day):\n",
    "    print(name_of_a_friend + \"! Good \" + time_of_day + \"!\")\n",
    "\n",
    "greet(\"Ingrid\", \"morning\")\n",
    "greet(\"Shri\", \"evening\")\n",
    "greet(\"Ainsley\", \"morning\")\n",
    "greet(\"Eli\", \"afternoon\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you notice we 'over-wrote' or 're-defined' the function called `greet()` ? It means that when you define another function of the same name, Python forgets what it used to do and takes on the new definition.\n",
    "\n",
    "So when you call `greet(\"Eli\", \"great\")` will you get \n",
    "\n",
    "`Eli! How are you? It is great to see you again!`\n",
    "\n",
    "or \n",
    "\n",
    "`Eli! Good great!`\n",
    "\n",
    "try it below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greet(\"Eli\", \"great\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Passing arguments into a function is something we do a lot in our daily life.\n",
    "# Arguments can be of different type: string (\"a\"), int (1), float(2.4) \n",
    "# But remember to change numbers into 'strings' before adding them into other strings.\n",
    "\n",
    "def order_coffee(size, number_of_sugars, type_of_milk):\n",
    "    print(\"Here's a \" + size + \" coffee with \" + str(number_of_sugars) + \" sugars and \" + type_of_milk + \" milk\")\n",
    "\n",
    "order_coffee(\"large\", 3, \"oat\")\n",
    "order_coffee(\"small\", \"no\", \"no\") # This middle string will also be put through str(), it is unaltered.\n",
    "order_coffee(\"filter\", \"2 brown\", \"skimmed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WATCH OUT: You can pass any number of attributes into a function but it's important not to confuse the order, or you will end up with unexpected results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def order_coffee(size, number_of_sugars, type_of_milk):\n",
    "    print(\"Here's a \" + size + \" coffee with \" + str(number_of_sugars) + \" sugars and \" + type_of_milk + \" milk\")\n",
    "\n",
    "order_coffee(\"oat\", \"large\", \"2 brown\") \n",
    "# Parameters are passed in a mixed-up order. It works, but makes no sense."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Scope (area, extent, reach): Context in which we do things and use variables.\n",
    "\n",
    "**This bit is important, but a bit complicated. If you don't get it, read it anyway, and come back to it at the end of the notebook**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every time we run a function we create a new \"scope\". You can think of scope as a new completely separate computer program, or a bubble, or a small world inside of each thing we ask to happen, where variables will change.\n",
    "\n",
    "BTW, the English word 'scope' sort of means \"area in which something matters\".\n",
    "\n",
    "We often have a scope inside of a scope. For example one scope (outside) would be the main program we are running. \n",
    "This is called the 'GLOBAL SCOPE'. Inside of that main program we can be running a function, so inside that function we have another scope clled 'LOCAL SCOPE' or 'FUNCTION SCOPE'. This is like a circle inside of a circle.\n",
    "\n",
    "Here are some SCOPE rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global/outside/generic scope variables.\n",
    "\n",
    "name = \"Wendy\"\n",
    "age = 32\n",
    "\n",
    "# Function with local/specific scope variables.\n",
    "\n",
    "def my_function():\n",
    "    day = \"Thursday\"\n",
    "    count = 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**SCOPE RULE 1. YOU CANNOT PEEK INSIDE OTHER (more specific) SCOPES, like OTHER FUNCTIONS**: \n",
    "Things from inside of a local scope (more specicfic), like variables within a function, are NOT available outside of their function (a more global/generic scope)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_number():\n",
    "    secret_number = 13 # We create a local variable inside of the scope of this function. \n",
    "    print(secret_number) # This will work, variable can be found.\n",
    "    \n",
    "print_number()\n",
    "print(secret_number) # This will error. \n",
    "\n",
    "# Because 'secret_number' is hidden within the scope of the function 'print_number'.\n",
    "\n",
    "# REMINDER:Aalways read errors from the bottom and look for ----> X    line number\n",
    "# Enable line numbers in View > toggle Line numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_number():\n",
    "    secret_number = 13 # We create a local variable inside of the scope of THIS function. \n",
    "    print(secret_number) # This will work, local variable.\n",
    "    \n",
    "def print_that_other_number():\n",
    "    print(secret_number) # This will NOT work. \n",
    "    # Because 'secret_number' is unknown in the scope of this fumction.\n",
    "\n",
    "print_number() # this will print\n",
    "print_that_other_number() # this will error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**SCOPE RULE 2. YOU CAN LOOK OUTSIDE TO MORE GLOBAL SCOPES but it can be TROUBLE** : Especially if you try to change what's the details of what's within them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will work. \n",
    "# Function scope is accessing outside variable. \n",
    "# But as you will see below it can be tricky.\n",
    "\n",
    "def print_number():\n",
    "    print(outside_number) \n",
    "\n",
    "outside_number = 7\n",
    "print_number()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**THE TRICKY BIT**: Below is an example of why it is often not a good idea to use variables from the outside, especially if you're planning to change them. The following functions might work or not, but it's quite an advanced topic to understand why."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will work.\n",
    "# Function scope is able to acess outside variable.\n",
    "def print_number():\n",
    "    print(outside_number) \n",
    "\n",
    "outside_number = 7\n",
    "print_number()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will NOT work.\n",
    "# Function scope is accessing outside variable.\n",
    "def print_number():\n",
    "    number = 10 \n",
    "    print(number)\n",
    "\n",
    "    # Here we CREATE ANOTHER VARIABLE in the function scope ALSO CALLED 'number'.\n",
    "    # And then we change that local number to 10 and we print it.\n",
    "    # Note: the global number is still 7 NOT 10, the local scope will be overidden.\n",
    "\n",
    "number = 7\n",
    "print(number)\n",
    "print_number()\n",
    "print(number) # When we make it here, the global number is still 7. Or maybe it should be 10? Oh no!\n",
    "\n",
    "# Not always ideal, and not what we may be expecting to happen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**THE TRICKY BIT**: Different scopes can have variables called with the same names. These similarly-named variables have nothing to do with each other. Just like the global and local 'outside_number' in our previous example. \n",
    "\n",
    "These concepts are really hard, and a bit confusing so if you do not fully understand this bit, just try to remember the rule: \n",
    "\n",
    "**Do not change variables from outside of your scope, if you can help it.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# COMPLICATED EXAMPLE OF SOMETHING GOING WRONG, feel free to skip this.\n",
    "\n",
    "# This example is really tricky. \n",
    "# At this point just remember:\n",
    "# Try to avoid changing variables from outside of their scope.\n",
    "# It can be a trap.\n",
    "\n",
    "# This will NOT work AND WILL ERROR.\n",
    "# Function scope will create it's own variable, but it first tries to use it.\n",
    "\n",
    "def print_number():\n",
    "    print(number) # This will already crash the program. Why?\n",
    "    number = 10 \n",
    "\n",
    "number = 7\n",
    "print(number) \n",
    "print_number() # By this point, the program would have crashed, out of confusion\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TO AVOID TROUBLE: Pass all required variables into functions as arguments!**: Each function should receive everything it needs within its arguments. These are basically variables you'll need later, passed inside of the `()` parts of your `function()` when you built it.\n",
    "\n",
    "**❤️ If there is one thing you remember from this lesson it could be this: Give the function everything it will need to do its job. (aka. Pass into the function (as arguments) every value you use inside that function.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# It's much better practice to pass things into functions:\n",
    "\n",
    "def print_number_twice(number_to_print):\n",
    "    # Notice that here we are not using 'outside_number'. \n",
    "    # But the 'number_to_print' from the functions arguments.\n",
    "    print(number_to_print, number_to_print) \n",
    "\n",
    "outside_number = 7 # This will not be used in the function scope. Instead, we'll pass it in as the argument.\n",
    "print_number_twice(outside_number) # Here 'number_to_print' becomes 'outside_number'(7).\n",
    "\n",
    "# This is safer, because there is no possibility for awkard changes.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Some more, mainly bad, examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# BAD EXAMPLE: But you'll see why, once we can return from functions.\n",
    "# Try to guess what will be printed before you run this cell.\n",
    "\n",
    "def change_name_and_print_it():\n",
    "    name = \"Maggy\"\n",
    "    print(name)\n",
    "\n",
    "name = \"Pim\"\n",
    "print(name)\n",
    "change_name_and_print_it()\n",
    "print(name)\n",
    "\n",
    "# what's going on here?? (below is the same code, but with some explanations) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# same as above, but explained\n",
    "def change_name_and_print_it():\n",
    "    name = \"Maggy\" # We create another unrelated variable 'name' in this scope, and we set it to \"Maggy\".\n",
    "    print(name) # Variable 'name' inside of this scope has value \"Maggy\". \n",
    "    # But it is A DIFFERENT VARIABLE to the 'name' from the higher/global scope (line 11) \n",
    "    # Changing it does not affect what will be 'name' from outside/global scope.\n",
    "\n",
    "name = \"Pim\" # Creating top level variable 'name'.\n",
    "print(name) # Name is \"Pim\".\n",
    "change_name_and_print_it() # Prints 'name' attached to scope of this function.\n",
    "print(name) # Name is still \"Pim\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ANOTHER BAD EXAMPLE:\n",
    "\n",
    "def sum(a,b,c):\n",
    "    result = a+b+c # Variable 'result' only exists in the local scope of this function.\n",
    "\n",
    "sum(1,2,4)\n",
    "print(result) # This will error, because there is no variable 'result' in the global scope.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ❤️ The final piece of the puzzle: Functions returning values (tricky at first, but incredibly useful)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We know that functions are blocks of code with some functionality that we want to reuse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_hello_twice():\n",
    "    print(\"hello\" + \"hello\") # This is not a very useful function. It can only print \"hellohello\".\n",
    "\n",
    "say_hello_twice()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We know that we can pass in parameters/arguments to functions, so that their functionality can be applied in different cotexts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_a_word_twice(word):\n",
    "        print(word + word) # This is more universal and reusable, you can apply it to any word.\n",
    "\n",
    "say_a_word_twice(\"Banana\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**RETURNING VALUES**: After function is done with its work, it can return the value to whoever called it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We have already seen this before with input(\"\") where after running input we capured/stored a value into a variable.\n",
    "\n",
    "my_name = input(\"who are you?\")\n",
    "print(my_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can make our functions RETURN a value, which means that after they are run, it can be stored in a variable.\n",
    "\n",
    "def combine_a_word_twice(word):\n",
    "    return word + word \n",
    "\n",
    "word_twice = combine_a_word_twice(\"Banana\")\n",
    "print(word_twice)\n",
    "\n",
    "# This is even more universal, because we can do things with the result of the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What happens with the returned value from a function? \n",
    "# It basically appears in the place where you called the function.\n",
    "# So when you run the code below, function 'combine_a_word_twice(\"hi\")' will be executed, and SWAPPED for \"hihi\".\n",
    "\n",
    "words = combine_a_word_twice(\"hi\")\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The above code is EXACTLY like saying.\n",
    "\n",
    "words = \"hihi\"\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**When the program is run, it will put the RESULT of the function, in the place where you CALLED THE FUNCTION.**\n",
    "\n",
    "Note: When a function reaches a ```return``` it will 'terminate' which means it will not look at any code after ```return```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_hello_twice(): # This function will return \"hello hello\".\n",
    "    return \"hello hello\"\n",
    "\n",
    "print( get_hello_twice() ) # So this is like calling print( \"hello hello\" )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_a_lucky_number(): # This function will return 7.\n",
    "    return 7\n",
    "\n",
    "print( get_a_lucky_number() ) # So this is like calling print( 7 )\n",
    "print( get_a_lucky_number() + get_a_lucky_number() ) # What would this do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum(a,b,c):\n",
    "    return a+b+c # We return the outcome of a+b+c to wherever this function is called.\n",
    "\n",
    "print( sum(1,2,4) ) # Is like calling 'print(7)' because 'sum(1,2,4)', returns 7.\n",
    "print( sum(10,10,10) ) # Is like calling 'print(30)' because 'sum(10,10,10), returns 30.\n",
    "print( sum(1,1,1) ) # Is like calling 'print(3)' because 'sum(1,1,1)', returns 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often you will want to capture an outcome of a variable (whatever it returns) into another variable, so that you can use it later. \n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  this is not very DRY\n",
    "\n",
    "def sum(a,b,c):\n",
    "    return a+b+c # We return the outcome of a+b+c to whereve this function is called.\n",
    "\n",
    "print(sum(1,2,4)) \n",
    "print(sum(1,2,4) * sum(1,2,4)) \n",
    "print(sum(1,2,4) + sum(1,2,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can see how this is more dry and versitile, as apposed to calling above code\n",
    "\n",
    "total = sum(1,2,4) # Is like calling 'total = 7' because 'sum(1,2,4)', returns 7.\n",
    "print(total) \n",
    "print(total * total) \n",
    "print(total + total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recap: Anatomy of a function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the below example:\n",
    "\n",
    "### **Definition** of a function:\n",
    "\n",
    "`\n",
    "def add_three_numbers(num_1, num_2, num_3):\n",
    "    sum = num_1 + num_2 + num_3\n",
    "    return sum\n",
    "`\n",
    "\n",
    "**function name**: ```add_three_numbers```\n",
    "\n",
    "**function arguments**:  ```num_1, num_2, num_3```\n",
    "\n",
    "**function body**: \n",
    "\n",
    "```\n",
    "sum = num_1 + num_2 + num_3\n",
    "return sum\n",
    "```\n",
    "        \n",
    "**function returns** value here `return sum`.\n",
    "    \n",
    "### **Calling a function:** \n",
    "    \n",
    "`add_three_numbers(1,3,6)` # we can pass any 3 arguments into this function.\n",
    "    \n",
    "Returned value of the function 'magically appears' where it was called.\n",
    "\n",
    "So `add_three_numbers(1,3,6)` will 'become' `10`.\n",
    "\n",
    "So `print(add_three_numbers(1,3,6))` is the same as `print(10)`.\n",
    "\n",
    "So `sum = add_three_numbers(1,3,6)` is the same as `sum = 10`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining all of our previous knowledge with functions, examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can include any type of code that we discussed before: variables, conditionals and calls to other functions. \n",
    "Basically any time you would like to re-use, or even clean up some of your code, you can build functions as a way of making your code more versatile for using in your work later on.\n",
    "\n",
    "During the course we will build a lot of our own functions and use other people's functions.\n",
    "\n",
    "Below are some examples of how functions can be used:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def combine_words(word_1, word_2, word_3):\n",
    "    return word_1 + word_2 + word_3\n",
    "\n",
    "print(combine_words(\"How \", \"are \", \"You?\") ) # I expect 'How are You?'.\n",
    "print(combine_words(\"Ba\",\"na\",\"na\"))          # I expect 'Banana'.\n",
    "print(combine_words(\"1\",\"2\",\"3\") )            # I expect '123'.\n",
    "print(combine_words(1,2,3) )                  # I expect ???? notice that this will work but makes no sense. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def are_words_identical_case_insensitive(word_1, word_2):\n",
    "    return word_1.lower() == word_2.lower()\n",
    "\n",
    "print(are_words_identical_case_insensitive(\"banana\", \"Banana\")) # I expect True.\n",
    "print(are_words_identical_case_insensitive(\"meh\", \"yup\")) # I expect False.\n",
    "print(are_words_identical_case_insensitive(\"onion\", \"onion\")) # I expect True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_larger_than_10(number):\n",
    "    if number > 10:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "print(is_larger_than_10(3) )   # I expect False.\n",
    "print(is_larger_than_10(10) )  # I expect False.\n",
    "print(is_larger_than_10(11) )  # I expect True.\n",
    "print(is_larger_than_10(100) ) # I expect True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# It is important to pay attention to indentation!\n",
    "\n",
    "def greet_based_on_time(feeling_good, hour, name):    \n",
    "    # First decide what is your mood.\n",
    "    if feeling_good == True:\n",
    "        mood_greeting =  \"Good\"\n",
    "    else:\n",
    "        mood_greeting =  \"Terrible\"\n",
    "    # Then decide what is the time of the day\n",
    "    if hour < 12:\n",
    "        time_of_the_day =  \"morning\"\n",
    "    elif hour < 17:\n",
    "        time_of_the_day =  \"afternoon\"\n",
    "    else:\n",
    "        time_of_the_day =  \"evening\"\n",
    "    \n",
    "    full_greeting = mood_greeting + \" \" + time_of_the_day + \", \" + name\n",
    "    return full_greeting\n",
    "    \n",
    "print( greet_based_on_time(False, 5, \"Mia\") )\n",
    "print( greet_based_on_time(True, 11, \"Cera\"))\n",
    "print( greet_based_on_time(False, 12, \"Sara\"))\n",
    "print( greet_based_on_time(True, 21, \"Minie\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OPTIONAL BUT VERY USEFUL FEATURES: Named arguments and Default Values.\n",
    "\n",
    "#### This part is optional, and a bit tricky. Feel free to come back to it later if you have little time. If you are moving on, skip to the next section, which starts with '⭐️⭐️⭐️💥....'\n",
    "\n",
    "(Optional notes) Default values: simplify code, but have to be at the end.\n",
    "Sometimes we would like to provide default values for some arguments. Mainly to make it easier to use our functions. \n",
    "In the coffee example above sometimes we would like to just say \"Coffee, please\" and the barista will know that we want e.g. a normal sized, no sugar, no milk, coffee."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For that to work without writing another simpler function, we could specify some DEFAULT ARGUMENTS. Basically, we can give some arguments a value that should be assumed, if we did not specify otherwise.\n",
    "\n",
    "A great thing about default arguments is that we can still use a function as we did above (specifying everything), but, as not everything needs to be stated, we can also use the a simplified version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def order_coffee(size = \"normal\", number_of_sugars = 0, type_of_milk = \"no\"): \n",
    "    return \"Here's a \" + size + \" coffee with \" + str(number_of_sugars) + \" sugars and \" + type_of_milk + \" milk\"\n",
    "\n",
    "# When no value is specified, Python will assume default values (\"normal\", 0, \"no\").\n",
    "\n",
    "print( order_coffee())                        #  Is like calling 'order_coffee(\"normal\", 0, \"no\")'.\n",
    "print( order_coffee(\"filter\"))                #  Is like calling 'order_coffee(\"filter\", 0, \"no\")'.\n",
    "print( order_coffee(\"filter\", 2))             #  Is like calling 'order_coffee(\"filter\", 2, \"no\")'.\n",
    "print( order_coffee(\"filter\", 2, \"skimmed\"))  #  Is like calling 'order_coffee(\"filter\", 2, \"skimmed\")'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Tricky bit: Why do default values have to be at the end?**\n",
    "\n",
    "Note: Some or all attributes can have default values, as long as the default arguments are after any stated values. \n",
    "So we could write:\n",
    "\n",
    "```\n",
    "def order_coffee( size,            number_of_sugars,     type_of_milk       ): \n",
    "def order_coffee( size,            number_of_sugars,     type_of_milk = \"no\"): \n",
    "def order_coffee( size,            number_of_sugars = 0, type_of_milk = \"no\"): \n",
    "def order_coffee( size = \"normal\", number_of_sugars = 0, type_of_milk = \"no\"): \n",
    "```\n",
    "\n",
    "And as shown above, when calling a function, we can skip some values. However, we need to make sure that Python will know what we're talking about and which argument is which.\n",
    "\n",
    "```\n",
    "order_coffee()\n",
    "order_coffee(\"filter\")\n",
    "order_coffee(\"filter\", 2)\n",
    "order_coffee(\"filter\", 2, \"skimmed\")\n",
    "```\n",
    "\n",
    "Why do they need to be at the end? Becuase if the attribute with a default value was in the middle, like in the below example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will return an error.\n",
    "# Read the error carefully.\n",
    "\n",
    "# Notice the last argument has no default.\n",
    "def order_coffee( size = \"normal\", number_of_sugars = 0, type_of_milk): \n",
    "    print(\"Here's a \" + size + \" coffee with \" + str(number_of_sugars) + \" sugars and \" + type_of_milk + \" milk\")\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here I tried to use the default for number_of_sugars but specify type_of_milk. That is not possible.\n",
    "\n",
    "def order_coffee(size = \"normal\", number_of_sugars = 0, type_of_milk = \"no\"): \n",
    "    print(\"Here's a \" + size + \" coffee with \" + str(number_of_sugars) + \" sugars and \" + type_of_milk + \" milk\")\n",
    "    \n",
    "order_coffee(\"filter\", \"skimmed\") # Here I hoped to use default 'number_of_sugars' which is 0.\n",
    "\n",
    "# Run this code, read the output, and notice what is wrong."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optional Named Arguments: Naming all arguments so that the order does not matter.\n",
    "\n",
    "Alternatively, there is an option to specify the name of each argument when you call a function. This could be useful in a few advanced scenarios, which are outside of the scope of this course. But here is an example of it, so that if you ever encounter it, it is familiar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Our 'order_coffee' function from before can be called in new ways:\n",
    "\n",
    "def order_coffee(size = \"normal\", number_of_sugars = 0, type_of_milk = \"no\"): \n",
    "    return \"Here's a \" + size + \" coffee with \" + str(number_of_sugars) + \" sugars and \" + type_of_milk + \" milk\"\n",
    "\n",
    "# As before you could call the function with all arguments.\n",
    "\n",
    "print( order_coffee(size = \"large\", number_of_sugars = 2, type_of_milk = \"soy\") )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Or you could specify just some arguments, other ones will use the default values (this is new).\n",
    "# Below is calling 'order_coffee(\"normal\", 0, \"soy\")' because 'size' and 'number_of_sugars' will take default values.\n",
    "\n",
    "print(order_coffee(type_of_milk = \"soy\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Below is calling 'order_coffee(\"normal\", 4, \"cow\")', because size will take the default value.\n",
    "\n",
    "print(order_coffee(number_of_sugars = 4, type_of_milk = \"cow\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Below is calling 'order_coffee(\"normal\", 0, \"no\")', all attributes will take default values.\n",
    "\n",
    "print(order_coffee())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ⭐️⭐️⭐️💥 What you have learned in this session: Three stars and a wish.\n",
    "**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: Noticing functions to make things more DRY\n",
    "\n",
    "Look at the code below. Can you think of a way to produce the same or very similar result. (solved example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# do you know this song? google it, and you will have even more fun solving this puzzle, while singing!\n",
    "print(\"The wheels on the bus go round and round\")\n",
    "print(\"Round and round, round and round\")\n",
    "print(\"The wheels on the bus go round and round\")\n",
    "print(\"All through the town\")\n",
    "print(\"\")\n",
    "print(\"The wipers on the bus go swish, swish, swish\")\n",
    "print(\"Swish, swish, swish, swish, swish, swish\")\n",
    "print(\"The wipers on the bus go swish, swish, swish\")\n",
    "print(\"All through the town.\")\n",
    "print(\"\")\n",
    "print(\"The people on the bus go chat, chat, chat\")\n",
    "print(\"Chat, chat, chat, chat, chat, chat\")\n",
    "print(\"The people on the bus go chat, chat, chat\")\n",
    "print(\"All through the town.\")\n",
    "print(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's do this step by step!\n",
    "# There seems to be a pattern betwen the verses of the song\n",
    "# some things are repeated\n",
    "\n",
    "def verse1():\n",
    "    print(\"The wheels on the bus go round and round\")\n",
    "    print(\"Round and round, round and round\")\n",
    "    print(\"The wheels on the bus go round and round\")\n",
    "    print(\"All through the town\")\n",
    "    print(\"\")\n",
    "    \n",
    "verse1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# there's the action bit that's repeated a lot. like 'round and round' or 'swish, swish, swish'\n",
    "def verse1():\n",
    "    action = \"round and round\"\n",
    "    print(\"The wheels on the bus go \" + action)\n",
    "    print(action + \" \" + action)\n",
    "    print(\"The wheels on the bus go \" + action)\n",
    "    print(\"All through the town\")\n",
    "    print(\"\")\n",
    "\n",
    "verse1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# amazing! let's try another thing:\n",
    "# there's the thing that performs the action (bus, wipers, etc)\n",
    "def verse1():\n",
    "    action = \"round and round\"\n",
    "    what = \"wheels\"\n",
    "    print(\"The \" + what + \" on the bus go \" + action)\n",
    "    print(action + \" \" + action)\n",
    "    print(\"The \" + what + \" on the bus go \" + action)\n",
    "    print(\"All through the town\")\n",
    "    print(\"\")\n",
    "\n",
    "verse1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ok, so maybe now we can abstract the function to work with EVERY VERSE?\n",
    "\n",
    "def any_verse(what, action):\n",
    "    print(\"The \" + what + \" on the bus go \" + action)\n",
    "    print(action + \", \" + action)\n",
    "    print(\"The \" + what + \" on the bus go \" + action)\n",
    "    print(\"All through the town\")\n",
    "    print(\"\")\n",
    "\n",
    "any_verse(\"wheels\",\"round and round\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# amazing, now we can sing all the verses just like this:\n",
    "\n",
    "any_verse(\"wheels\", \"round and round\")\n",
    "any_verse(\"wipers\", \"swish, swish, swish\")\n",
    "any_verse(\"people\", \"chat, chat, chat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Another task (your turn):\n",
    "\n",
    "Below is a British nursery rhyme from the 18th century. Notice much of it is repeated. Can you identify how you could produce the same prints, but with use of functions?\n",
    "\n",
    "    London Bridge is falling down,\n",
    "    Falling down, falling down,\n",
    "    London Bridge is falling down,\n",
    "    My fair Lady.\n",
    "\n",
    "    Build it up with wood and clay,\n",
    "    Wood and clay, wood and clay,\n",
    "    Build it up with wood and clay,\n",
    "    My fair Lady.\n",
    "\n",
    "    Wood and clay will wash away,\n",
    "    Wash away, wash away,\n",
    "    Wood and clay will wash away,\n",
    "    My fair Lady.\n",
    "\n",
    "    Build it up with bricks and mortar,\n",
    "    Bricks and mortar, bricks and mortar,\n",
    "    Build it up with bricks and mortar,\n",
    "    My fair Lady."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use functions to print above nursery rhyme. Write your code here.\n",
    "# There should functions be used: Identify parts that are simmilar but different. \n",
    "# The 'different parts' are usually variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ⛏ Bonus Minitask: Re-using functions.\n",
    "\n",
    "First: smaller_number (already solved for you)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a function that takes two numbers and returns the smaller one\n",
    "\n",
    "def smaller_number(num1, num2):\n",
    "    if num1 <= num2:\n",
    "        return num1\n",
    "    else:\n",
    "        return num2\n",
    "    \n",
    "    \n",
    "print(smaller_number(3,4))\n",
    "print(smaller_number(10,4))\n",
    "print(smaller_number(10,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another step: what if there are 3 numbers? It gets a bit more complicated.\n",
    "\n",
    "def smaller_number_of_3(num1, num2, num3):\n",
    "    if num1 <= num2 and num1 <= num3:\n",
    "        return num1\n",
    "    elif num2 <= num1 and num2 <= num3:\n",
    "        return num2\n",
    "    else:\n",
    "        return num3\n",
    "    \n",
    "    \n",
    "print(smaller_number_of_3(1,4,3))\n",
    "print(smaller_number_of_3(3,10,-2))\n",
    "print(smaller_number_of_3(10,10,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ok... and what if there are 4 numbers?\n",
    "\n",
    "def smaller_number_of_4(num1, num2, num3, num4):\n",
    "    if (num1 <=  num2 and num1 <=  num3 and num1 <=  num4):\n",
    "        return num1\n",
    "    elif (num2 <=  num1 and num2 <=  num3 and num2 <=  num4):\n",
    "        return num2\n",
    "    elif (num3 <=  num1 and num3 <=  num2 and num3 <=  num4):\n",
    "        return num3\n",
    "    else:\n",
    "        return num4\n",
    "     \n",
    "print(smaller_number_of_4(1,2,3,4))\n",
    "print(smaller_number_of_4(1,2,0,4))\n",
    "print(smaller_number_of_4(2,2,3,3))\n",
    "print(smaller_number_of_4(3,3,3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do you see any repetition above? Think about which parts of one function are similarly used in another one.\n",
    "\n",
    "For example, consider the below definitions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function can be broken down with use of a 'helper function'.\n",
    "\n",
    "def smaller_number(num1, num2):\n",
    "    if num1 <= num2:\n",
    "        return num1\n",
    "    else:\n",
    "        return num2\n",
    "    \n",
    "def smaller_number_of_3(num1, num2, num3):\n",
    "    return smaller_number(smaller_number(num1, num2),num3)\n",
    "\n",
    "def smaller_number_of_4(num1, num2, num3, num4):\n",
    "    return smaller_number(smaller_number(num1, num2), smaller_number(num3, num4))\n",
    "     \n",
    "# Draw it on paper if it helps to visulise.\n",
    "\n",
    "print(smaller_number_of_3(1,2,3))\n",
    "print(smaller_number_of_4(1,2,0,4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Another ⛏ Bonus Minitask: Separating functions.\n",
    "\n",
    "\n",
    "- Take the function below, seen earlier in this notebook, and refactor it to better use the power of functions.\n",
    "- Break it down into simpler, but a greater number of functions. \n",
    "- You may allow them to have default and named arguments.\n",
    "- Add any more features or elements that you'd like.\n",
    "\n",
    "Remember to regularly save your progress (File > Save, OR a keyboard shortcut (Ctrl/Cmd + S), OR click the 'Disc' icon in the top left corner of your Notebook toolbar). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The function to break down into 2-3 smaller ones:\n",
    "\n",
    "def greet_based_on_time(feeling_good, hour, name):    \n",
    "    if feeling_good == True:\n",
    "        mood_greeting =  \"Good\"\n",
    "    else:\n",
    "        mood_greeting =  \"Terrible\"\n",
    "    \n",
    "    if hour < 12:\n",
    "        time_of_the_day =  \"morning\"\n",
    "    elif hour < 17:\n",
    "        time_of_the_day =  \"afternoon\"\n",
    "    else:\n",
    "        time_of_the_day =  \"evening\"\n",
    "    \n",
    "    full_greeting = mood_greeting + \" \" + time_of_the_day + \", \" + name\n",
    "    return full_greeting\n",
    "    \n",
    "print(greet_based_on_time(False, 5, \"Mia\"))\n",
    "print(greet_based_on_time(True, 11, \"Cera\"))\n",
    "print(greet_based_on_time(False, 12, \"Sara\"))\n",
    "print(greet_based_on_time(True, 21, \"Minie\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do you think you could create functions `mood_as_word`, `hour_into_time_of_the_day` and `words_into_sentence` (or whatever else you'd like to call them), that will perform individual parts of the above function `greet_based_on_time`?\n",
    "\n",
    "If you manage to complete this task, then the below code would work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that this will not work yet. You need to build the three helper functions first.\n",
    "# There are 3 hints below that will guide you on this journey, but try to solve it by yourself first.\n",
    "# Uncover hints one by one as you go, to challenge yourself (not all at once).\n",
    "\n",
    "def greet_based_on_time(feeling_good, hour, name):    \n",
    "    mood_greeting =  mood_as_word(feeling_good)\n",
    "    time_of_the_day =  hour_into_time_of_the_day(hour)\n",
    "    full_greeting =  words_into_sentence(mood_greeting, time_of_the_day, name)\n",
    "    return full_greeting\n",
    "\n",
    "print(greet_based_on_time(False, 5, \"Mia\"))  # Expected 'Terrible morning, Mia'.\n",
    "print(greet_based_on_time(True, 11, \"Cera\"))  # Expected 'Good morning, Cera'.\n",
    "print(greet_based_on_time(False, 12, \"Sara\")) # Expected 'Terrible afternoon, Sara'.\n",
    "print(greet_based_on_time(True, 21, \"Minie\")) # Expected 'Good evening, Minie'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary style='color:blue'>HINT 1: How to start breaking it down? CLICK HERE TO SEE THE ANSWER. BUT REALLY TRY TO DO IT YOURSELF FIRST!</summary>\n",
    "\n",
    "    Here's some code to get you started, copy it into a code cell so that you can run and edit the code.\n",
    "    \n",
    "    ### BEGIN SOLUTION\n",
    "    \n",
    "    def mood_as_word(are_you_feeling_good):    \n",
    "        # ??? what will be here?\n",
    "\n",
    "    print( mood_as_word(True) ) # expected 'Good'\n",
    "    print( mood_as_word(False) ) # expected 'Terrible'\n",
    "    \n",
    "    \n",
    "    def hour_into_time_of_the_day(hour):    \n",
    "        # ??? what will be here?\n",
    "\n",
    "    print( hour_into_time_of_the_day(1) )  # expected 'morning'\n",
    "    print( hour_into_time_of_the_day(3) )  # expected 'morning'\n",
    "    print( hour_into_time_of_the_day(11) ) # expected 'morning'\n",
    "    print( hour_into_time_of_the_day(12) ) # expected 'afternoon'\n",
    "    print( hour_into_time_of_the_day(15) ) # expected 'afternoon'\n",
    "    print( hour_into_time_of_the_day(16) ) # expected 'afternoon'\n",
    "    print( hour_into_time_of_the_day(17) ) # expected 'evening'\n",
    "    print( hour_into_time_of_the_day(18) ) # expected 'evening'\n",
    "    print( hour_into_time_of_the_day(23) ) # expected 'evening'\n",
    "    \n",
    "    \n",
    "    def greeting_for(mood, time, name):\n",
    "        # ??? what will be here?\n",
    "    \n",
    "    print( greet_based_on_time(False, 5, \"Mia\") )  # expected 'Terrible morning, Mia'\n",
    "    print( greet_based_on_time(True, 11, \"Cera\"))  # expected 'Good morning, Cera'\n",
    "    print( greet_based_on_time(False, 12, \"Sara\")) # expected 'Terrible afternoon, Sara'\n",
    "    print( greet_based_on_time(True, 21, \"Minie\")) # expected 'Good evening, Minie'\n",
    "    \n",
    "    ### END SOLUTION\n",
    "    \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary style='color:blue'>HINT 2: broken down functions? CLICK HERE TO SEE THE ANSWER. BUT REALLY TRY TO DO IT YOURSELF FIRST!</summary>\n",
    "\n",
    "    Here's some code to get you started, copy it into a code cell so that you can run and edit the code.\n",
    "    \n",
    "    ### BEGIN SOLUTION\n",
    "    \n",
    "    def mood_as_word(are_you_feeling_good):    \n",
    "        if are_you_feeling_good == True:\n",
    "            return \"Good\"\n",
    "        else:\n",
    "            return \"Terrible\"\n",
    "\n",
    "    print( mood_as_word(True) ) # expected 'Good'\n",
    "    print( mood_as_word(False) ) # expected 'Terrible'\n",
    "\n",
    "    ### \n",
    "\n",
    "    def hour_into_time_of_the_day(hour):    \n",
    "        if hour < 12:\n",
    "            return \"morning\"\n",
    "        elif hour < 17:\n",
    "            return \"afternoon\"\n",
    "        else:\n",
    "            return \"evening\"\n",
    "\n",
    "    print( hour_into_time_of_the_day(1) )  # expected 'morning'\n",
    "    print( hour_into_time_of_the_day(3) )  # expected 'morning'\n",
    "    print( hour_into_time_of_the_day(11) ) # expected 'morning'\n",
    "    print( hour_into_time_of_the_day(12) ) # expected 'afternoon'\n",
    "    print( hour_into_time_of_the_day(15) ) # expected 'afternoon'\n",
    "    print( hour_into_time_of_the_day(16) ) # expected 'afternoon'\n",
    "    print( hour_into_time_of_the_day(17) ) # expected 'evening'\n",
    "    print( hour_into_time_of_the_day(18) ) # expected 'evening'\n",
    "    print( hour_into_time_of_the_day(23) ) # expected 'evening'\n",
    "\n",
    "\n",
    "    # you could even do this:\n",
    "\n",
    "    def words_into_sentence(mood_word, time_word, name):\n",
    "        return mood_word + \" \" + time_word + \", \" + name\n",
    "\n",
    "    print( words_into_sentence('Terrible', 'morning', \"Mia\") )  # expected 'Terrible morning, Mia'\n",
    "    print( words_into_sentence('Good', 'morning', \"Cera\"))      # expected 'Good morning, Cera'\n",
    "    print( words_into_sentence('Terrible', 'afternoon', \"Sara\")) # expected 'Terrible afternoon, Sara'\n",
    "    print( words_into_sentence('Good', 'evening', \"Minie\")) # expected 'Good evening, Minie'\n",
    "\n",
    "    ### END SOLUTION\n",
    "    \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary style='color:blue'>HINT 3: combining it together into greet_based_on_time CLICK HERE TO SEE THE ANSWER. BUT REALLY TRY TO DO IT YOURSELF FIRST!</summary>\n",
    "\n",
    "    Here's some code to get you started, copy it into a code cell so that you can run and edit the code.\n",
    "    \n",
    "    ### BEGIN SOLUTION\n",
    "    \n",
    "    def greet_based_on_time(feeling_good, hour, name):    \n",
    "        mood_greeting =  mood_as_word(feeling_good)\n",
    "        time_of_the_day =  hour_into_time_of_the_day(hour)\n",
    "        full_greeting =  words_into_sentence(mood_greeting, time_of_the_day, name)\n",
    "        return full_greeting\n",
    "\n",
    "    print( greet_based_on_time(False, 5, \"Mia\") )  # expected 'Terrible morning, Mia'\n",
    "    print( greet_based_on_time(True, 11, \"Cera\"))  # expected 'Good morning, Cera'\n",
    "    print( greet_based_on_time(False, 12, \"Sara\")) # expected 'Terrible afternoon, Sara'\n",
    "    print( greet_based_on_time(True, 21, \"Minie\")) # expected 'Good evening, Minie'\n",
    "\n",
    "    # This could also be, but it starts looking like spaghetti or tangled earphones 🤔\n",
    "\n",
    "    def greet_based_on_time(feeling_good, hour, name):    \n",
    "        return words_into_sentence(  mood_as_word(feeling_good), hour_into_time_of_the_day(hour), name)\n",
    "\n",
    "    print( greet_based_on_time(True, 11, \"Cera\"))  # expected 'Good morning, Cera'\n",
    "    \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
}