Workshop4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CH160: Introduction to Python IV - Functions\n",
    "\n",
    "<img src=\"./STUFF/StarWars.jpg\" width=\"400\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0 - Required packages\n",
    "This workshop will use some additional Python modules, so we need to import these first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#IMPORT ADDITIONAL PYTHON MODULES USED IN THIS WORKSHOP\n",
    "\n",
    "import numpy as np\n",
    "import random          # random number generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 - Introduction\n",
    "\n",
    "In previous workshops of this course you have already met, and made use of, several built-in Python functions, including  ```print()```, ```len()```, ```range()```, *etc.*, and several further functions which are not part of the core Python language, but can be added by *importing* additional packages, *e.g.*  ```array()```, ```arange()```, ```linspace()```, *etc.* which are part of the NumPy module. In this workshop you will learn how to define and use your own Python functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 - What is a function anyway?\n",
    "You may have come across the concept of a function in mathematics (if you have not, or you need a refresher, functions are covered in lecture 4 of CH162:Mathematics for Chemists, part 1), where they are used to describe the relationship - or mapping - between one or more input variables, and an output variable. Often a mathematical function is written as:\n",
    "$$z=f(x,\\,y)$$\n",
    "Where this notation indicates that $f$ is a function which operates on the input variables $x$ and $y$ to generate the output $z$. \n",
    "\n",
    "Programming functions are much more general than this (*i.e.*, we are not limited to the mathematical manipulation of numbers), and the availability of both pre-defined functions and the ability to define and write your own functions is a central part of nearly all programming languages!\n",
    "\n",
    "In programming a function is a self-contained block of code which is designed to perform a very specific task - for instance the in-built ```len()``` function can be used to tell you how many elements there are in a list or array, whilst ```print()``` is the function we use if we wish to print things to screen. In each case we call the function by name, and include some appropriate arguments within the parentheses (*i.e.* a text string in the case of ```print()```), Python then runs the block of code associated with the called function and performs the requested action, before returning to your code at the point it left off.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 - Why do we care about functions?\n",
    "### The beauty of reusable code\n",
    "Often when you are writing code you will perform the same series of operations over and over again. You could simply copy-paste the useful code wherever it is used. However, if you subsequently modified the code in question you would need to make the same modification in every location it was reused.\n",
    "\n",
    "A better solution is to write your useful bit of code in the form of a Python function. Whenever you need to use the code you then just need to call the function rather then copy it verbatim. If you later want to change how it works, you only need to make changes in one location - the place you defined your function - and the changes will automatically be picked up whenever the function is called."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 - The anatomy of a function\n",
    "## 2.1 - Defining functions\n",
    "We create functions using the following syntax:\n",
    "```python\n",
    "def <function_name>(<[parameters]>):\n",
    "    <body>\n",
    "    return <value>\n",
    "```\n",
    "\n",
    "Here the command ```def``` is used to tell Python that a new function is being defined, ```<function_name>``` is the name of the function, ```<[parameters]>``` is an optional comma-separated list of input parameters which are passed to the function, and  ```<body>``` is the series of python commands you want to perform (this can include loop structures, conditional statements, and even call other functions). Note that just like the loop and conditional structures we met in workshop 3, the ```<body>``` code needs to be indented. \n",
    "\n",
    "The ```return``` statement is probably the part of a Python function that causes the most confusion. It is an optional statement which comes at the end of the ```<body>```, and its role is to pass the value of the specified object (remember that in Python an *object* includes things such as numbers, strings, lists, arrays, tuples, *etc.*) out of the function for use later on - most functions you write will need to include a ```return``` statement to be useful.\n",
    "\n",
    "As a simple example, consider the following user-defined function: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#OUR FIRST FUNCTION\n",
    "\n",
    "# Create a function called 'HW', which returns the string 'Hello, World!' when called, note that even\n",
    "# though this function does not contain any parameters in its definition, the parentheses following \n",
    "# <function_name> must still be included. \n",
    " \n",
    "def HW():\n",
    "    return(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the above cell was run, you will notice that it doesn't appear to do anything - it certainly does not print anything to screen like promised! This is because the above code cell just defines the function, in order to use a function we need to call it using the following syntax:\n",
    "```python\n",
    "<function_name>(<[arguments]>)\n",
    "```\n",
    "where ```<[arguments]>``` are the values passed into the function, and correspond to the ```<[parameters]>``` in the function definition.\n",
    "\n",
    "From this, we see that we run our ```HW()``` function as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, World!'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#CALLING A FUNCTION\n",
    "\n",
    "# To use our user-defined function, we just need to call it. Since the function has no parameters, \n",
    "# no arguments are needed (we still need to type out the parentheses though)\n",
    "HW()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 - Parameters and arguments\n",
    "The function ```HW()``` did not have any parameters in its definition, and consequently did not require any arguments to be specified when it was called.  While this can sometimes be useful, more often we want to pass data to a function so as to change its behaviour/output from one call to the next. In order to do this, we make use of arguments. \n",
    "\n",
    "### 2.2.1 - Positional arguments\n",
    "The simplest way to do this is to use *positional arguments*. As an example of this, lets write a function which takes a single number as an argument, multiplies this number by 2, and prints the result. We first need to define our function as before, but now we need to specify the required parameter inside the parentheses: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#SPECIFYING FUNCTION PARAMETERS\n",
    "\n",
    "# Define a function 'times2' which has a single parameter 'x' and returns the value of x*2 when called\n",
    "def times2(x):\n",
    "    x_times_2 = x * 2\n",
    "    return x_times_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we call the function we need to specify the value of the argument by typing a number inside the parentheses: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "26.8\n"
     ]
    }
   ],
   "source": [
    "#CALLING FUNCTIONS WITH ARGUMENTS\n",
    "\n",
    "# The function is called by specifying a numerical value for the argument, we can print the output directly...\n",
    "print(times2(4))        #Should print the result 4 * 2\n",
    "\n",
    "# Or we can store it as a variable for use later on\n",
    "value=times2(13.4)     #Should store the result 13.4 * 2 in the variable 'value'\n",
    "print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hopefully you can see that the parameter ```x``` is behaving like a variable which takes on the value of its corresponding argument when the function is called."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 1:\n",
    "Write a function that returns the square of any number passed to it as an argument (*i.e.* if the function is called with ```6.3``` as an argument, it will return ```39.69``` as output). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39.69\n",
      "16\n",
      "1000000\n"
     ]
    }
   ],
   "source": [
    "#TASK 1 ANSWER:\n",
    "\n",
    "def sqr(x):\n",
    "    x_squared=x**2\n",
    "    return x_squared\n",
    "\n",
    "# Check the function works by calling it several times using different arguments and printing the output\n",
    "print(sqr(6.3))\n",
    "print(sqr(4))\n",
    "print(sqr(1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another example, suppose that we wanted to write a function that sums all of the numbers between 0 and 100 (inclusive). We saw in the last workshop how we could use the following ```for``` loop to achieve this:\n",
    "```python\n",
    "s=0\n",
    "for i in range(101):\n",
    "   s+=i\n",
    "```\n",
    "\n",
    "To change how many numbers are included in the sum, we need to change the number used in the ```range()``` command. If we specify this number as a function parameter, we can control its value by setting it in a function argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of all numbers up to 100 = 5050\n",
      "Sum of all numbers up to 3333 = 5556111\n"
     ]
    }
   ],
   "source": [
    "#OUR FIRST 'USEFUL' FUNCTION\n",
    "\n",
    "# Define a function 'number_sum' which has a single parameter - 'max_n'.\n",
    "# This parameter is then used to define the upper limit in the range() command of a \n",
    "# for loop in the body of the function.\n",
    " \n",
    "def number_sum(max_n):\n",
    "    # Initialise the accumulator\n",
    "    s=0\n",
    "    \n",
    "    # Prepare for loop which performs running sum of all numbers up to (but not including) max_n\n",
    "    for i in range(max_n):      \n",
    "        s+=i       # Note double indentation of this line \n",
    "    \n",
    "    return s       # Note that indentation of return statement has returned to normal \n",
    "\n",
    "# Sum the numbers 1-100 by calling 'number_sum' with the number 101 as its argument\n",
    "print(\"Sum of all numbers up to 100 =\", number_sum(101))\n",
    "\n",
    "# Sum the numbers 1-3333 by calling 'number_sum' with the number 3334 as its argument\n",
    "print(\"Sum of all numbers up to 3333 =\", number_sum(3334))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 2:\n",
    "Write a function called ```square_or_cube(number)```, which returns the square of ```number``` if it is even, or its cube if it is an odd number.\n",
    "\n",
    "**Extra challenge:**\n",
    "For a number to be even or odd it needs to be an integer. See if you can make your function print a statement informing the user of this if they attempt to pass a non-integer argument to the function.\n",
    "\n",
    "**Useful commands:**\n",
    "- ```x%2``` will return ```0``` if ```x``` is exactly divisible by 2\n",
    "- ```type(number)``` will return ```int``` if ```number``` is an integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Argument must be an integer\n",
      "Argument must be an integer\n",
      "27\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "#TASK 2 ANSWER:\n",
    "\n",
    "def square_or_cube(number):\n",
    "    if type(number)!=int:\n",
    "        result = \"Argument must be an integer\"\n",
    "    elif number%2==0:\n",
    "        result = number**2\n",
    "    else:\n",
    "        result = number**3\n",
    "    return result\n",
    "\n",
    "# Code checking\n",
    "print(square_or_cube(\"three\"))\n",
    "print(square_or_cube(3.1))\n",
    "print(square_or_cube(3))\n",
    "print(square_or_cube(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that arguments are not limited to being numbers. Strings, lists, arrays, tuples, *etc.* can also be used as arguments. For example, we could have use a list or a NumPy array as the argument when calling the ```times2()``` function defined above, with the returned value reflecting how lists and arrays respond to direct mathematical manipulation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 1, 2, 3, 4]\n",
      "[2 4 6 8]\n"
     ]
    }
   ],
   "source": [
    "#USING LISTS AND ARRAYS AS ARGUMENTS\n",
    "\n",
    "# Create a list of numbers\n",
    "number_list=[1,2,3,4]\n",
    "\n",
    "# Create an array of numbers based on 'number_list'\n",
    "number_array=np.array(number_list)\n",
    "\n",
    "# Use a list as the argument for the 'times2()' function \n",
    "print(times2(number_list))     #multiplying a list by 2 duplicates the list\n",
    "\n",
    "# Use an array as the argument for the 'times2()' function \n",
    "print(times2(number_array))    #multiplying an array by 2 multiplies each element individually"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specifying multiple parameters\n",
    "Our functions do not need to limited to a single parameter - we can include as many as we want! To do this, we specify all of the parameters as a comma-separated list inside the parentheses. When the function is called, we need to specify a corresponding list of arguments. For example, we could write a function that subtracts one user-specified number from another:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "-4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#MULTIPLE FUNCTION PARAMETERS\n",
    "\n",
    "# Define a function 'subtract' which has two parameters 'num1' and 'num2' and prints the value of num1-num2 \n",
    "def subtract(num1, num2):\n",
    "    result=num1 - num2\n",
    "    return result\n",
    "\n",
    "# To call the function, we need to specify two arguments corresponding to 'num1' and 'num2'\n",
    "print(subtract(10, 5))   #should print the result 10 - 5\n",
    "print(subtract(3, 7))    #should print the result 3 - 7\n",
    "print(subtract(7, 3))    #should print the result 7 - 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hopefully the last two examples above will have helped you spot one of the reasons why the title of this subsection is \"Positional arguments\". The order you type in the arguments when calling the function must match the order in which their corresponding parameters were specified in the original function definition - in the above example the first argument sets the value of the first parameter, ```num1```, and the second argument sets the value of the second parameter, ```num2```.\n",
    "\n",
    "Not only must the order of arguments in the function call match the order of the parameters in the function definition, but the number of each must be equal too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TOO FEW ARGUMENTS\n",
    "\n",
    "# Call subtract function with only one argument\n",
    "subtract(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TOO MANY ARGUMENTS\n",
    "\n",
    "# Call subtract function with three arguments when only two parameters are specifed in function definition\n",
    "subtract(2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 3:\n",
    "The following equation has four parameters:\n",
    "\n",
    "$$q=\\frac{a+b-c}{d}$$\n",
    "\n",
    "Write a function that requires values for each of $a$, $b$, $c$, and $d$ as arguments, and prints the value of $q$.\n",
    "\n",
    "If your function works correctly, input values of $a=10$, $b=30$, $c=20$, and $d=40$ should yield the result $q=0.5$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n"
     ]
    }
   ],
   "source": [
    "#TASK 3 ANSWER\n",
    "\n",
    "# Define function with four parameters\n",
    "def f(a, b, c, d):\n",
    "    total=((a + b - c) / d)\n",
    "    return total\n",
    "\n",
    "# Test the function using the supplied parameter values\n",
    "print(f(10, 30, 20, 40))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2 - Keyword (named) arguments\n",
    "The requirement for arguments to be specified in the same order as function parameters can be relaxed if we make use of *keyword arguments*. In order to use a keyword argument, rather than just specifying a parameter value (as with positional arguments) we need to include a keyword too: \n",
    "```python\n",
    "<keyword>=<value>\n",
    "```\n",
    "where ```<keyword>``` matches a parameter name in the function definition.\n",
    "\n",
    "For example, the parameters in the function ```subtract()``` defined above are named ```num1``` and ```num2```, we can define the value of these parameters explicitly by passing the following keyword arguments to the function:\n",
    "\n",
    "```python\n",
    "num1=<value>\n",
    "```\n",
    "and\n",
    "```python\n",
    "num2=<value>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# USING KEYWORD ARGUMENTS\n",
    "\n",
    "#Call subtract function using positional arguments - order matters\n",
    "print(subtract(4, 9))\n",
    "print(subtract(9, 4))\n",
    "\n",
    "#Call subtract function using keyword arguments - can be written in any order\n",
    "print(subtract(num2=9, num1=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you attempt to reference a parameter which does not exist using a keyword argument your code will generate an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# USING NON-EXISTENT KEYWORDS\n",
    "\n",
    "# Attempting to pass the keyword argument num3=<value> will not work because it references a\n",
    "# parameter (num3) which is not included in the function definition\n",
    "print(subtract(num3=9, num1=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although the order we pass keyword arguments to a function does not matter, the total number of arguments and parameters must still match."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mixing keyword types\n",
    "You can call functions using a mixture of positional and keyword arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2.5\n",
      "-2.5\n",
      "-2.5\n"
     ]
    }
   ],
   "source": [
    "# MIXING POSITIONAL AND KEYWORD ARGUMENTS\n",
    "\n",
    "# Define a function which has three parameters\n",
    "def multiparam(a, b, c):\n",
    "    return (a-b)/c\n",
    "    \n",
    "# Test the function using positional arguments, keyword arguments, and a mixture of the two\n",
    "print(multiparam(3, 8, 2))\n",
    "print(multiparam(b=8, c=2, a=3))\n",
    "print(multiparam(3, c=2, b=8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When both positional and keyword arguments are present, all the positional arguments must be written first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-32-c4b9b6f3efbe>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-32-c4b9b6f3efbe>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    print(multiparam(a=3, b=8, 2))\u001b[0m\n\u001b[0m                              ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "# ALL POSITIONAL ARGUMENTS MUST COME BEFORE ANY KEYWORD ARGUMENTS\n",
    "\n",
    "# Placing a positional argument after a keyword argument will generate an error\n",
    "print(multiparam(a=3, b=8, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A limitation in mixing positional and keyword arguments is that positional arguments **will always** specify the values of the function parameters on a first come, first served basis regardless of whether their value is explicitly set using a keyword argument after. For instance, the following function call will not work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "multiparam() got multiple values for argument 'b'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-7339d18862db>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# Attempting to use positional arguments to set the value of 'a' and 'c' and a keyword argument for 'b'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# will not work\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmultiparam\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: multiparam() got multiple values for argument 'b'"
     ]
    }
   ],
   "source": [
    "#POSITIONAL ARGUMENTS OPERATE ON A FIRST COME, FIRST SERVED BASIS\n",
    "\n",
    "# Attempting to use positional arguments to set the value of 'a' and 'c' and a keyword argument for 'b'\n",
    "# will not work\n",
    "print(multiparam(3, 2, b=8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.3 - Default parameters\n",
    "Oftentimes it is useful to define default values for function parameters - values that are appropriate for most uses of the function - while still being able to change away from this default if you wish. In Python we do this by specifying a function parameter in the form:\n",
    "```python\n",
    "<parameter>=<value>\n",
    "```\n",
    "where ```<value>``` becomes the default value for ```<parameter>```.\n",
    "\n",
    "The below example is a simple function that prints the value of a number (x) raised to a power (p). If we were to decide that we are usually interested in squaring out number (*i.e.* p=2), then we could write our function as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# USING DEFAULT PARAMETERS\n",
    "\n",
    "# Function that takes a number 'x' and raises it to the power 'p'. 'p' is given a default value of 2\n",
    "# This function returns a string as output\n",
    "def power(x, p=2):\n",
    "    x_power_p=x**p\n",
    "    return x_power_p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The advantage of using default parameters is that when we call the function we do not have to pass it a value for p if we are happy to use the default (they are often called optional parameters for this reason). If however we decide that we want p to take on a different value, we are free to specify this when the function is called:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "[ 4  9 16 25]\n",
      "8\n",
      "[ 16  81 256 625]\n"
     ]
    }
   ],
   "source": [
    "# USING DEFAULT VALUES IN FUNCTIONS, OR JUST BE AWKWARD AND SPECIFY YOUR OWN VALUES...\n",
    "\n",
    "# Use default value for p - only one argument specifying value of x is needed\n",
    "print(power(2))    # Returns 2**2\n",
    "print(power(np.array([2,3,4,5])))    # Squares each element of the array\n",
    "\n",
    "# Passing two arguments allows us to change away from default value of p\n",
    "print(power(2, 3)) # Returns 2**3\n",
    "print(power(np.array([2,3,4,5]), 4)) # Raises each element of the array to the power of 4\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "### Task 4:\n",
    "In workshops 1 and 2 you were asked to calculate the gravitational force $F_g$ that attracts two bodies of mass $M$ and $m$ kg, respectively, as a function of their separation $r$ (in metres):\n",
    "\n",
    "$$\n",
    "F_g(r)= - \\frac{G \\cdot M \\cdot m}{r^2}\n",
    "$$\n",
    "\n",
    "Where $G=6.674 \\cdot 10^{-11}$ m$^{3}\\cdot$kg$^{-1}\\cdot$s$^{-2}$ is the *gravitational constant*.\n",
    "\n",
    "So far, we have calculated $F_g$ for fixed values of $M$ and $m$ (1 and 0.5 kg, respectively), while varying the value of $r$. In this workshop we are going to write a function which allows us to rapidly calculate the value of $F_g$ for *any* combination of values for $M$, $m$, and $r$.\n",
    "\n",
    "* <b>Step 1</b>: Define a function ```Fg(r, M, m)``` which has three parameters:\n",
    "    - \"r\" has no default value\n",
    "    - \"M\" which has a default value of $1$\n",
    "    - \"m\" which has a default value of $0.5$<br>\n",
    "* <b>Step 2</b>: Create an array called ```separation``` containing the whole numbers 1 through 10 inclusive (use either the ```linspace``` or ```arange``` commands to automatically generate this array).\n",
    "\n",
    "* <b>Step 3</b> Run your function pasing the array generated in step 2 as your required argument (```r```), and leave M and m at their defaults. Compare you answer to that obtained from Task 7 of Workshop 2 - they should be the same.\n",
    "\n",
    "* <b>Step 4</b> Repeat step 3, but use values of $M=6$ and $m=0.1$ instead of the defaults.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3.33700000e-11 -8.34250000e-12 -3.70777778e-12 -2.08562500e-12\n",
      " -1.33480000e-12 -9.26944444e-13 -6.81020408e-13 -5.21406250e-13\n",
      " -4.11975309e-13 -3.33700000e-13]\n",
      "[-4.00440000e-11 -1.00110000e-11 -4.44933333e-12 -2.50275000e-12\n",
      " -1.60176000e-12 -1.11233333e-12 -8.17224490e-13 -6.25687500e-13\n",
      " -4.94370370e-13 -4.00440000e-13]\n"
     ]
    }
   ],
   "source": [
    "# TASK 4 ANSWER\n",
    "\n",
    "# Write our function \n",
    "def Fg(r, M=1, m=0.5):\n",
    "    result=-(6.674e-11*M*m)/r**2\n",
    "    return result\n",
    "\n",
    "# Create array containing the integers 1-10\n",
    "r=np.arange(1,11)\n",
    "\n",
    "# Calculate Fg using default values for M and m\n",
    "print(Fg(r))\n",
    "\n",
    "# Calculate Fg using manually defined values for M and m\n",
    "print(Fg(r, M=6, m=0.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 - Returning multiple values\n",
    "Up to now, all of our examples have returned a single result. To return two or more values from a function we pack them into a tuple (see workshop 2)...\n",
    "\n",
    "<img src=\"./STUFF/touple.jpg\" width=\"400\">\n",
    "\n",
    "[sorry not sorry](https://www.youtube.com/watch?v=ZBVrPWwSlRM)\n",
    "\n",
    "For example, the function ```multi_output``` below populates an array with random numbers, and then calculates the mean and standard deviation of the array elements. Once finished, the array and its mean and standard deviation values are packed into a tuple (recall that a tuple consists of a number of objects separated by commas) which is then returned by the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 0.,  4.,  3., 10.,  5.]), 4.4, 3.2619012860600183)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#RETURNING MULTIPLE VALUES? PACK THEM ALL INTO A TUPLE!\n",
    "\n",
    "def multi_output(samples):\n",
    "    \n",
    "    # Prepare array with a number of elements defined by the 'samples' parameter, each of which is 0 intitially\n",
    "    random_number_array=np.zeros(samples)\n",
    "    \n",
    "    # for loop replaces each element of array in turn with random integer between 0-10 inclusive\n",
    "    for i in range(samples):\n",
    "        random_number_array[i]=(random.randint(0,10))\n",
    "    \n",
    "    # Use built=in NumPy functions to calculate mean and standard deviation of array elements\n",
    "    array_mean=np.mean(random_number_array)\n",
    "    array_std_dev=np.std(random_number_array)\n",
    "    \n",
    "    # Return statement packs 'random_number_array', 'array_mean', and 'array_std_dev' into a tuple\n",
    "    return random_number_array, array_mean, array_std_dev\n",
    "\n",
    "# Function outputs a tuple containing an array with 5 elements, and two numbers specifying the mean and std. dev.\n",
    "multi_output(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the three returned objects (one array and two numbers) individually we need to *unpack* the tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random array = [ 9.  5.  4.  3.  2.  3.  0.  4.  7. 10.]\n",
      "Mean of values = 4.7\n",
      "Standard deviation = 2.968164415931166\n"
     ]
    }
   ],
   "source": [
    "# UNPACKING THE TUPLE GIVES ACCESS TO THE INDIVIDUAL OBJECTS\n",
    "\n",
    "# Call function again (will generate different values for everything), and unpack \n",
    "# the tuple by assigning each object to a separate variable ('array', 'mean', and 'std_dev').\n",
    "array, mean, std_dev=multi_output(10)\n",
    "\n",
    "# Print the objects individually\n",
    "print(\"Random array =\", array)\n",
    "print(\"Mean of values =\", mean)\n",
    "print(\"Standard deviation =\", std_dev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 5:\n",
    "The solutions (or *roots*) to the equation:\n",
    "    $$ax^2+bx+c=0$$ \n",
    "are given by the quadratic formula:\n",
    "$$x=\\frac{-b\\pm\\sqrt{b^2-4ac}}{2a}$$\n",
    "\n",
    "Write a function that passes the values of $a$, $b$, and $c$ as arguments, and returns the two roots of the equation. Test your function using the input values $a=1$, $b=4$, and $c=-5$ which should return roots at $x=-5$ and $x=1$.\n",
    "\n",
    "**Useful commands:**\n",
    "- ```np.sqrt(x)``` returns the square root of ```x```. Note that you will get an error message if ```x``` is negative (in our case, this error will signify that the quadratic equation in question has no real roots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First root is x = -5.0\n",
      "Second root is x = 1.0\n"
     ]
    }
   ],
   "source": [
    "# TASK 5 ANSWER:\n",
    "\n",
    "def quadratic_solver(a, b, c):\n",
    "    d=np.sqrt(b**2-4*a*c)\n",
    "    root1=-(b+d)/(2*a)\n",
    "    root2=-(b-d)/(2*a)\n",
    "    \n",
    "    return root1, root2\n",
    "\n",
    "root1, root2 = quadratic_solver(1, 4, -5)\n",
    "print('First root is x =', root1)\n",
    "print('Second root is x =', root2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 - Variable scope\n",
    "## 3.1 - Why do we use return statements?\n",
    "\n",
    "Up to now, every function we have written in this workshop has included a return statement, even though they are optional - functions will perform their task perfectly well without these statements bolted onto the end. To understand why we often choose to include them in a function, we need to understand a little bit about how python treats variables in functions. \n",
    "\n",
    "As an example, consider the simple function ```plus2(x)``` below, which takes a value for ```x``` as an argument, adds two to it, and prints the result to screen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A FUNCTION WITH NO RETURN STATEMENT - WHATS THE WORST THAT CAN HAPPEN?\n",
    "\n",
    "# Write a function that takes an argument x, and adds two to its value. Note that\n",
    "# this function has a print statement in place of a return statement\n",
    "def plus2(x):\n",
    "    manipulated_x=x+2\n",
    "    print(x, \"+ 2 =\", manipulated_x)       # print the manipulated value of x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check that this function is working as intended in the usual way..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 + 2 = 7\n"
     ]
    }
   ],
   "source": [
    "# THE FUNCTION WORKS, HUZZAH!\n",
    "\n",
    "# Call our 'plus2' function by passing it a number as argument. If the function is \n",
    "# working the value of x+2 should be printed to screen\n",
    "plus2(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we wanted to use this new ```x+2``` value later on in our code. We might assume that since the function ```plus2(x)``` stores its result as the variable ```manipulated_x``` before printing, then we could just use this variable directly..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'manipulated_x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-aa0af25d1c25>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# Attempt to print the variable 'manipulated_x'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmanipulated_x\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'manipulated_x' is not defined"
     ]
    }
   ],
   "source": [
    "# WE HAVE A PROBLEM...\n",
    "\n",
    "# Attempt to print the variable 'manipulated_x' \n",
    "print(manipulated_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equally, when we attempt to print the output of a function lacking a return statement (or assign the output to a new variable) we get an odd looking result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# WHAT IS THE OUTPUT OF A FUNCTION WITH NO RETURN STATEMENT?\n",
    "\n",
    "# Write a function that cubes a number passed to it as an argument, but forget to include a return statement\n",
    "def cube(x):\n",
    "    x_cubed = x**3\n",
    "    \n",
    "# Print the output of the function - much like we have done for nearly every function up to now\n",
    "print(cube(3)) \n",
    "\n",
    "# Assign the output of the function to a variable, and print the variable\n",
    "value=cube(5)\n",
    "print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What has happened here? The first code cell showed us that the function ```plus2()``` is working as intended (the value of ```manipulated_x``` printed to screen is two higher than the input value as intended), but when we check on the value of ```manipulated_x``` after the function has done its thing, we are told that ```name 'manipulated_x' is not defined``` - *i.e.*, there is no such variable! \n",
    "\n",
    "This behaviour arises because any variable created *inside a function* - as ```manipulated_x``` is in this example - does not exist anywhere outside of the function, they are *local variables* (we say that the variables exist within the *local scope* of the function). This also means that the value of any such variable cannot be accessed outside of the function. \n",
    "\n",
    "The second function prints ```None``` to screen rather than the expected results (27 and 125, respectively). Rather confusingly, ```None``` is the 'value' Python assigns to objects when they have no value - this is not the same as having a value of 0 or an empty string). Without a ```return``` statement, a function doesn't output anything when it has finished, so any subsequent attempt use this empty output, *i.e.* in a print statement or variable assignment, will necessarily result in ```None``` and much head scratching.\n",
    "\n",
    "Both of these problems can be avoided by adding a return statement to our function, which allow us to output the value of a variable when the function has finished.\n",
    "\n",
    "**Note:** this only returns the value associated with the variable, not the variable itself - the variable remains local even if it is named in the return statement. This is why we need to assign a new variable name to the output of a function in order to use the associated value later on in the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 6:\n",
    "The code in the cell below attempts to calculate the balance of a savings account at the end of each year up to a maximum of four years. The account initially has a balance of £100, and the annual interest rate is 0.72% (this was the best interest rate I could find for a savings account in August 2020!). As written, the code does not work. Identify the problem(s) and provide a working alternative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Balance after year 1 = 100\n",
      "Balance after year 2 = 100\n",
      "Balance after year 3 = 100\n",
      "Balance after year 4 = 100\n"
     ]
    }
   ],
   "source": [
    "# TASK 6 CODE (incorrect code)\n",
    "\n",
    "# The following code does not work as intended - identify the problem, and correct it in the cell below\n",
    "balance = 100\n",
    "def add_interest(balance, rate):\n",
    "    balance += balance * rate/100\n",
    "    \n",
    "for year in range(1, 5):\n",
    "    add_interest(balance, 0.72)\n",
    "    print ('Balance after year', year, '=', balance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Balance after year 1 = 100.72\n",
      "Balance after year 2 = 101.445184\n",
      "Balance after year 3 = 102.1755893248\n",
      "Balance after year 4 = 102.91125356793856\n"
     ]
    }
   ],
   "source": [
    "# TASK 6 ANSWER:\n",
    "# Copy and modify the code from the cell above to make it work correctly\n",
    "\n",
    "balance = 100\n",
    "def add_interest(balance, rate):\n",
    "    balance += balance * rate/100\n",
    "    return balance\n",
    "    \n",
    "for year in range(1, 5):\n",
    "    balance=add_interest(balance, 0.72)\n",
    "    print ('Balance after year', year, '=', balance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 - Global and local variables\n",
    "### 3.2.1 - Using global variables in functions\n",
    "While a variable created inside a function cannot be used outside of the function, the reverse is not true. This is because variables defined outside of functions (this includes when the output of a function is assigned to a variable) are classed as *global* and are available everywhere within the program file/Jupyter notebook. For example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a local variable This is a global variable\n"
     ]
    }
   ],
   "source": [
    "# ACCESSING GLOBAL VARIABLES INSIDE FUNCTIONS\n",
    "\n",
    "# Define a function that prints two variables, one ('loc') defined within the function \n",
    "# definition, and one ('glob') defined outside of the function\n",
    "\n",
    "def variable_print():\n",
    "    loc = \"This is a local variable\"\n",
    "    print(loc, glob)\n",
    "    \n",
    "glob=\"This is a global variable\"\n",
    "\n",
    "variable_print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, note that we were able to use a global variable in a function without passing it as an argument first (also note that it didn't matter that the gobal variable had not been defined when the function was defined - it does, of course, matter if the global variable isn't defined by the time that the function is first *called*!)\n",
    "\n",
    "A function can define a local variable with the same name as an existing global variable. In such a situation, the local variable *will not overwrite the value of the global variable*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "local\n",
      "global\n"
     ]
    }
   ],
   "source": [
    "# LOCAL AND GLOBAL VARIABLES CAN SHARE THE SAME NAME, BUT STILL HAVE DIFFERENT VALUES\n",
    "\n",
    "# Define a variable 'a' which exists in the global scope\n",
    "a=\"global\"\n",
    "\n",
    "def local_vs_global_scope():\n",
    "\n",
    "    # Define a variable, also called 'a' which exists in the local scope, and print it to screen\n",
    "    a=\"local\"\n",
    "    print(a)\n",
    "\n",
    "    \n",
    "# Call the function\n",
    "local_vs_global_scope()\n",
    "\n",
    "# Print the variable 'a' to screen - has its value been overwritten by the function?\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 - Can global variables be modified inside functions?\n",
    "What happens to a global variable when its value is modified *within* a function? The answer to this question depends upon whether the variable is passed as an argument or not, and whether it is classed as *mutable* or *immutable*!\n",
    "\n",
    "### 3.3.1 - Global variable not passed as an argument\n",
    "If a global variable is not passed to a function as an argument, then its value cannot be modified by the function at all. Attempting to do so will result in an error message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    },
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'global_x' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-3ce0302f2ee2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;31m# Call both functions - the first should work, the second will not\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mfunc2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-17-3ce0302f2ee2>\u001b[0m in \u001b[0;36mfunc2\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;31m# func2() attempts to modify the value of global variable without passing it as an argument first - very naughty!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfunc2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m     \u001b[0mglobal_x\u001b[0m\u001b[0;34m+=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mglobal_x\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'global_x' referenced before assignment"
     ]
    }
   ],
   "source": [
    "# Define a variable 'global_x' which exists in the global scope - and can therefore be accessed by all functions\n",
    "global_x=5\n",
    "\n",
    "# func() prints the value of the global variable - this is fine\n",
    "def func():\n",
    "    print(global_x)\n",
    "\n",
    "# func2() attempts to modify the value of global variable without passing it as an argument first - very naughty!\n",
    "def func2():\n",
    "    global_x+=2\n",
    "    print(global_x)\n",
    "\n",
    "# Call both functions - the first should work, the second will not\n",
    "func()\n",
    "func2()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.2 - Variables passed as arguments\n",
    "If we pass a variable to a function as an argument, then its value can be manipulated within the function. We need to know whether this change in value persists outside of the function. From what we learned in section 3.1 and 3.2, we might expect that any change is limited to within the function only.\n",
    "\n",
    "What happens when our input variable is a simple number?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial value of x in function = 2\n",
      "Final value of x in function = 4\n",
      "Global value of x after function = 2\n"
     ]
    }
   ],
   "source": [
    "# IMMUTABLE OBJECTS ARE NOT MODIFIED PERMENENTLY BY FUNCTIONS \n",
    "\n",
    "# Function can be passed either a number or an array as an argument, and prints the square\n",
    "def square(x):\n",
    "    print(\"Initial value of x in function =\", x)\n",
    "    x**=2\n",
    "    print(\"Final value of x in function =\", x)\n",
    "\n",
    "# Define global variable 'x', pass it to our function as an argument, then see if the function\n",
    "# has caused a permanent change to its value\n",
    "x = 2\n",
    "square(x)\n",
    "print(\"Global value of x after function =\", x)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is telling us that, as expected, the change to the value of the global variable is local to the function - the value of ```x``` seen by the rest of the program does not change. \n",
    "\n",
    "What happens when we pass an array to the function instead? We can use the same function (```square(x)```) as above, and follow the same procedure: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial value of x in function = [2 3 4]\n",
      "Final value of x in function = [ 4  9 16]\n",
      "Global value of x after function = [ 4  9 16]\n"
     ]
    }
   ],
   "source": [
    "# MUTABLE OBJECTS ARE MODIFIED PERMENENTLY BY FUNCTIONS \n",
    "\n",
    "# Define global variable 'x', which is an array this time. Pass it to our function as an argument, \n",
    "# then see if the function has caused a permanent change to its value\n",
    "x = np.array([2, 3, 4])\n",
    "square(x)\n",
    "print(\"Global value of x after function =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that this time the changes made to the variable persist in the main program! The differing behaviour between numbers and arrays is very important and can easily catch you out - more generally we can say that:\n",
    "- Changes to number, string, and tuple variables passed to a function do not persist once the function has finished (unless you explcitly code this behaviour *via* a return statement as in Task 6)\n",
    "- Changes to list and array variables passed to a function persist once the function has finished\n",
    "\n",
    "The reason for this differing behaviour is that numbers, strings, and tuples are classed as immutable objects, while lists and arrays are mutable. As a reminder, an object is classed as being mutable if its value can be changed after creation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because immutable objects can't be changed, attempting to modify them within a function results in the creation of a new local object with the same name, but the old global object that was passed as an argument remains unchanged. Conversely, mutable objects can be changed, so the function will modify the original (global) object, rather than having to create a new (local) object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4 - Modular code is the best code!\n",
    "We have seen that Python functions are an extremely useful way of avoiding needless repetition in code - if you use a block of code repeatedly, make it into a function!\n",
    "\n",
    "Another useful facet of functions is that they allow us to break complex processes up into separate functions, each of which performs a specific task. Breaking a large task into smaller sub-tasks like this is known as *modularisation*, and often makes the problem easier to think about. As your programs become more complicated, it also helps maintain the readability of your code (essential when you revisit it after a long period!), and makes them easier to maintain and troubleshoot. \n",
    "\n",
    "In this final section, we apply this modular paradigm in a series of tasks which will result in us writing a short program allowing us to numerically differentiate simple mathematical functions. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 7:\n",
    "\n",
    "In this question we are going to write a simple program which is able to differentiate mathematical functions numerically. To do this, we are going to make direct use of the <i>first principles definition</i> of a derivative:\n",
    "    $$ $$\n",
    "    $$f'(x)=\\lim_{h\\to 0}\\frac{f(x+h)-f(x)}{h}$$\n",
    "    $$ $$    \n",
    "where $f(x)$ and $f'(x)$ are our original function and its derivative, respectively, and $h$ is the stepsize (which we called $\\Delta x$ in the CH162:Mathematics for chemists notes). From this equation you can see that in order to calculate a derivative numerically, all we need is the defintion of the function $f(x)$ itself, and a value for the step size - numerical differentiation just requires that we are able to write functions!\n",
    "\n",
    "As a very simple example lets calculate the derivative of $f(x)=x^{4}$ at $x=1.3$. The analytical solution, $f'(x)=4x^{3}$, tells us that the answer should be 8.788. How well will our numerical approxiation perform? We are going to break this task into two modular pieces: \n",
    "\n",
    "### Step (i)\n",
    "\n",
    "The first step is to define the mathematical function $(f(x)=x^{4})$ using python. In the code cell below, complete the definition of the function ```x_pwr4()``` which reads in a value for $x$, and returns the value $x^4$.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your code works correctly, move on to step (ii)\n"
     ]
    }
   ],
   "source": [
    "# TASK 7 - STEP (i) ANSWER:\n",
    "\n",
    "# Complete the function definition below - remember to include a return statement!\n",
    "def x_pwr4(x): \n",
    "    y=x**4\n",
    "    return y      \n",
    "\n",
    "########################################################################################\n",
    "#                                                                                      #\n",
    "#                                 CODE CHECKING                                        #\n",
    "#                                                                                      #\n",
    "# The code below will check that the function `x_pwr4` is working correctly - do not   #\n",
    "# change it or ignore the message printed                                              #\n",
    "########################################################################################\n",
    "\n",
    "if x_pwr4(2)==16 and x_pwr4(8)==4096:\n",
    "    print(\"Your code works correctly, move on to step (ii)\")\n",
    "else:\n",
    "    print(\"Your code contains an error, you need to fix it before moving onto step (ii)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 7 - step (ii):\n",
    "\n",
    "Now that the function ```x_pwr4()``` is working correctly, we can use it in the calculation of the deriviative of $x^{4}$. To do this, we are going to write a second function, ```differentiate()```, containing two parameters - the stepsize, $h$ (which we shall give a default value of 0.01), and the value of $x$ we are using to evaluate the derivative.\n",
    "\n",
    "Using the first principles definition of a derivative given above, complete the function definition in the code cell below to return the derivative of $x^{4}$.\n",
    "\n",
    "**Useful tips:**\n",
    "- Functions can be called from within other functions, and their output used as normal\n",
    "- Both ```x``` and ```h``` are numbers, therefore ```x+h``` is also a number, and can be passed to a function as an argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Congratulations, you have succesfully written a numerical differentiation code! Move onto Task 8.\n"
     ]
    }
   ],
   "source": [
    "# TASK 7 - STEP (ii) ANSWER:\n",
    "\n",
    "# Complete the function definition below\n",
    "\n",
    "def differentiate(x, h=1.e-2):\n",
    "    value=(x_pwr4(x+h)-x_pwr4(x))/h\n",
    "    return value\n",
    "\n",
    "########################################################################################\n",
    "#                                                                                      #\n",
    "#                                 CODE CHECKING                                        #\n",
    "#                                                                                      #\n",
    "# The code below will check that the function `differentiate()` is working correctly   #\n",
    "#                                                                                      #\n",
    "########################################################################################\n",
    "\n",
    "if np.around(differentiate(1.3),decimals=4)==8.8899:\n",
    "    print(\"Congratulations, you have succesfully written a numerical differentiation code! Move onto Task 8.\")\n",
    "else:\n",
    "    print(\"Your code contains an error, you need to fix it before moving onto Task 8\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 8:\n",
    "If you succesfully completed Task 7, your ```differentiate()``` function should return a value of approximately 8.89 for the derivative of $x^4$ evaluated at $x=1.3$. While this is close to the true value of 8.788, can we do better?\n",
    "\n",
    "The first-principles definition of a derivative is taken in the limit of $h$ approaching zero. This suggests to us that if we decrease the value of $h$ (and thus approach the limit of $h=0$), our numerical answer should become more accurate. Using the function ```differentiate()``` from task 7, repeat the above calculation using step sizes of $h=1,\\,0.1,\\,0.01,\\,0.001,\\,0.0001$, and $0.00001$. Try to include a loop in your code which automates the function calls, rather than manually calling the function for each value of $h$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h = 1; numerical approximation = 25.128\n",
      "h = 0.1; numerical approximation = 9.855\n",
      "h = 0.01; numerical approximation = 8.890\n",
      "h = 0.001; numerical approximation = 8.798\n",
      "h = 0.0001; numerical approximation = 8.789\n",
      "h = 1e-05; numerical approximation = 8.788\n"
     ]
    }
   ],
   "source": [
    "# TASK 8 ANSWER:\n",
    "\n",
    "# Create a list containing required step sizes\n",
    "h_list=[1, 1.e-1, 1.e-2, 1.e-3, 1.e-4, 1.e-5]\n",
    "\n",
    "for h in h_list:\n",
    "    num_approx=differentiate(1.3, h)\n",
    "    print(\"h = {}; numerical approximation = {:1.3f}\".format(h,num_approx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "### Task 9:\n",
    "Repeat Task 7, but make a program capable of finding the derivative with respect to $x$ of any mathematical function having the general formula:\n",
    "\n",
    "$$f(x)=ax^{p}$$\n",
    "\n",
    "where the values of $a$ and $p$ are passed to the function as arguments.\n",
    "\n",
    "Check your code by evaluating the derivative of $f(x)=4x^3$ when $x=3$. If your code is working correctly it should return a value of approximately 108 (the exact value returned will depend upon the stepsize chosen)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "108.00003602184916\n"
     ]
    }
   ],
   "source": [
    "# TASK 9 ANSWER:\n",
    "\n",
    "# Create function to return value of a*x^p for any combination of a, x, and p\n",
    "def f(x, a, p):\n",
    "    y=4*x**3\n",
    "    return y\n",
    "\n",
    "# Differentiate function needs to be modified to account for the extra parameters in 'f()'\n",
    "def differentiate(x, a, p, h):\n",
    "    value=(f(x+h,a,p)-f(x,a,p))/h\n",
    "    print(value)\n",
    "    \n",
    "differentiate(x=3, a=4, p=3, h=1.e-6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}