exercises/Python_Principles_5.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/chris-lovejoy/CodingForMedicine/blob/main/exercises/Python_Principles_5.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Principles\n",
    "\n",
    "# Part 5: Structuring Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Till now, we have created a few simple lines of code to do tasks. But once we know the basics, knowing and recalling syntax takes a back seat to thinking about how to structure your code so it's readable. You can imagine that a file with hundreds of lines of unstructured code would be hard to read and think about.\n",
    "\n",
    "Python gives us techniques to make our code more readable and maintainable. We can write a file of hundreds of lines of code easily. But this becomes unreadable as we need to keep many lines of code in our minds. \n",
    "\n",
    "Also, when something doesn't work or a change is needed this becomes an increasingly complicated task. We should strive to make code that runs correctly and is easy to change in the future.\n",
    "\n",
    "Functions and modules allow us to segment code, give them names and structure the code into small pieces that can be easily read and reasoned. Using functions and modules, we can make it more maintainable when we need to debug or change the code."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Links to Exercises\n",
    "[Python Principles 1](./Python_Principles.ipynb)\n",
    "\n",
    "[Python Principles 2](./Python_Principles_2.ipynb)\n",
    "\n",
    "[Python Principles 3](./Python_Principles_3.ipynb)\n",
    " \n",
    "[Python Principles 4](./Python_Principles_4.ipynb)\n",
    " \n",
    "[Python Principles 5](./Python_Principles_5.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "We have talked about functions up and until now in an indirect way. A function is a way to define a specific block of code that can be called and executed at a later time. \n",
    "\n",
    "This aspect of being able to contain several lines of code in one block is a powerful concept in structuring your code. \n",
    "\n",
    "### Calling a function\n",
    "\n",
    "Before we create our own functions, we should discuss the term **calling**. We've been using methods which are functions on objects throughout Python Principles. Calling a function means we want to execute the code within the function at a time that makes sense within the program. \n",
    "\n",
    "An object that can be called is **callable**, and in this case, functions are callable.\n",
    "\n",
    "If you have a name that represents a function, you can call that object by putting open and closed parentheses around it. For example `print()` is a callable object with the name `print`.\n",
    "\n",
    "Run the snippet below, we've seen the example before. Notice how we need to supply it with the `number` variable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5,6]\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We print the list as defined in the line 1 here. Notice how we use the open and closed brackets to call the function and pass `numbers` in between the brackets. In the next section, we will explain this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameters and Arguments\n",
    "\n",
    "An argument is an input to a function. We put the arguments inside the parentheses of a function to make them available to the function when we call it.\n",
    "\n",
    "The **parameter** is the variable name we see in between the parentheses of a function call and the arguments are the values assigned to the parameter.\n",
    "\n",
    "There are two types of arguments, positional and keyword arguments. A **positional argument** means the position of when the argument is specified matters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1,2,3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The positional argument `1,2,3,4` matters where they're ordered. If we change the argument order, the output will be different.\n",
    "\n",
    "**Keyword arguments** are called named arguments, a name is declared and specified as a value. They're more descriptive than positional arguments.\n",
    "\n",
    "The `print()` function also has a keyword argument called `sep` which is used to separate the positional arguments with a specific character.\n",
    "\n",
    "Run the code snippet below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1,2,3,sep=\", \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keyword argument's order does not matter, unlike positional arguments.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only constraint keywords have is that they should come after any positional argument. \n",
    "\n",
    "Run the code snippet below to see the difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sep=\",\", 1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here Python throws a syntax error, because keyword arguments must come before positional arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return Values\n",
    "\n",
    "The output of a function is the return value of a function. \n",
    "\n",
    "Run the example below. Here we're using the sum function which returns the sum of a numbers for a given data type passed to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5,6]\n",
    "sum(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `number` list is the argument and the return value is the sum of those numbers. When you run this snippet, you may think that Python printed the values, however, it actually returned the number. \n",
    "\n",
    "The difference between output and return is that we could store the value returned from a function inside a variable by assigning the function call to it.\n",
    "\n",
    "Run the example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = [1,2,3,4,5,6]\n",
    "total = sum(numbers)\n",
    "total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default return value\n",
    "\n",
    "Not all functions have return values, for example the print function doesn't.\n",
    "\n",
    "Run the code snippet below.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = print('Aaron')\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the name has been assigned `None`. \n",
    "\n",
    "`None` is a special value that says the function doesn't have a return value. In Python, we assume functions will perform an action or return something, but not both. The print function performs an action but does not return a value. Whereas the `sum` function returns a value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining a function\n",
    "\n",
    "Let's create a function that prints out a greeting. The `def` keyword is used to define a function. It requires a variable name and a set of open and closed parentheses.\n",
    "\n",
    "The syntax of a function is the following:\n",
    "\n",
    "```\n",
    "def <function_name>(): \n",
    "\tstatements\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets see an example of a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting():\n",
    "\tprint('Hello World')\n",
    "\n",
    "greeting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code snippet above, we define the function `greeting`. On the second line, we indent and call the print function to print the string `Hello World`. Lastly, we call the function `greeting`.\n",
    "\n",
    "What happens if you try to pass an argument into the `greeting` function?\n",
    "\n",
    "In the cell below, pass an argument into the greeting function call and run the cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting():\n",
    "\tprint('Hello World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note we get an error because we don't define any parameters to pass arguments to within the function definition. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions accepting arguments\n",
    "\n",
    "For arguments to be passed to a function we need to define the parameter in our function. We do this by naming it between parentheses.\n",
    "\n",
    "See below the example and run the code snippet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(name):\n",
    "\tprint(\"Hello\", name)\n",
    "\n",
    "greeting(\"Aaron\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have defined the greeting function with a parameter, and we print a string out depending on what is passed as an argument. In this case, we pass the string `Aaron` as the argument which is assigned to the `name` parameter. The string `Hello Aaron` is printed to the output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, create a function that prints names, make sure you use a parameter so that you can pass any name when doing a function call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that if we define a parameter in a function, and don't pass an argument python will throw an error.\n",
    "\n",
    "Consider the code snippet above\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(name):\n",
    "\tprint(\"Hello\", name)\n",
    "\n",
    "greeting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python throws an error requiring an argument to be given. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default argument values\n",
    "\n",
    "We can make arguments optional by providing a default value. To do so we use the equals sign after the parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(name=\"world\"):\n",
    "\tprint(\"Hello\",name)\n",
    "greeting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note just because we've defined a default value, doesn't mean we can't specify an argument.\n",
    "\n",
    "Run the code snippet below to see this in action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(name=\"World\"):\n",
    "\tprint(\"Hello\", name)\n",
    "\n",
    "greeting(\"Aaron\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the string `Hello Aaron` still gets printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, create a function that prints names but we want a default value of a string that is your own name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Returning values\n",
    "\n",
    "We have discussed the inputs that functions can have which can be used to do actions. Functions can also return a value after some work has been done. \n",
    "\n",
    "To do this in Python, we use the `return` keyword. \n",
    "\n",
    "Let's see an example of how this could work. Run the snippet below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def product(numbers):\n",
    "\ttotal = sum(numbers)\n",
    "\treturn total\n",
    "\n",
    "sumNum = product([1,2,3])\n",
    "sumNum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value `6` gets returned. We define a function `product` and pass in a list of numbers. Within the function, we declare the `total` variable. The sum built-in function has the numbers list passed as an argument. The return value of the sum function is assigned to the `total` variable. We use the `return` statement to return the total. The variable `sumNum` is declared and assigned the return value of the `product` function.\n",
    "\n",
    "The key to creating a good function is only doing one task. For example, adding two numbers together. A good practice to get into is to comment on what a function should be doing when you write your functions. If you find it hard to reason what the function is doing, it probably means it should be split into more functions till it does one task."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, create a function `returnLetters` that takes as input a person's name and returns the first and last letter of that name. If no name is provided as argument the function should return `'No names given'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accepting any number of arguments\n",
    "\n",
    "In Python, sometimes you won't know how many arguments you need to accept. For example, a function that accepts a set of data as input but you don't know how much data you'll have to work with.\n",
    "\n",
    "You could keep adding parameters to the function to accept these arguments or create a list of the data. But adding this extra data structure is perhaps not something you want in your function.\n",
    "\n",
    "When a * precedes the parameters of a function, Python will accept any number of positional arguments as input. Any arguments given are packed into a tuple that the function can refer to. This is called **argument tuple unpacking**. \n",
    "\n",
    "Run the snippet below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(*args):\n",
    "\tprint(args)\n",
    "\tprint(type(args), len(args))\n",
    "\n",
    "f(1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output of this function is a tuple `(1,2,3)` and some information about the argument (the type and the length). It identifies that when a `*` precedes a parameter name, it creates a tuple of arguments `1`,`2`,`3` and assigns this to the parameter `args`. We output the length of `args` corresponding to the number of arguments given to the function\n",
    "\n",
    "For example lets create a function that accepts any names and we want to print them all."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(*names):\n",
    "\tfor name in names:\n",
    "\t\tprint(name)\n",
    "\n",
    "greet('Aaron','Chris') \n",
    "print('---')\n",
    "greet('Aaron','Chris','Guzal','Alex')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code snippet above, we output the names `Aaron` and `Chris` from the first function invocation. `*names` signifies we want to capture all positional arguments. This creates a tuple `names` that we can loop through and then print the arguments one at a time.\n",
    "\n",
    "In the second invocation, we supplied more arguments. We can supply any number of arguments, or not know how many arguments will be passed to the function and still be able to use it within the function code.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, create a function that takes as input any number of strings. The function should output all names with all letters as uppercase. If we provide any number of strings to the function, it should output each one in turn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword-only function arguments\n",
    "\n",
    "In the previous section, we discussed how to accept an unlimited number of arguments. But what happens if you define parameters and arguments after argument tuple unpacking (for example `*names` in the previous example)?\n",
    "\n",
    "Let's run the snippet of code below to understand this better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(*names, greeting):\n",
    "\tfor name in names:\n",
    "\t\tprint(name, greeting)\n",
    "greet('Aaron','Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python throws an error here because we've created a parameter `greeting` after `*names` and in Python any parameter specified after `*names` has to be a keyword argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(*names, greeting=\"Hello\"):\n",
    "\tfor name in names:\n",
    "\t\tprint(name, greeting)\n",
    "greet('Aaron')\n",
    "greet('Aaron',greeting=\"Hi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the first function invocation the output prints `Aaron Hello`. This is because the default argument is `Hello`. In the second invocation, we specify the keyword argument `Hi` instead so Python prints out `Aaron Hi` instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accepting arbitary keyword arguments\n",
    "\n",
    "In Python, you may not know how many keyword arguments that need to be passed to a function. We can use the `**` operator to accept any number of keyword arguments in a function.\n",
    "\n",
    "We use the characters `**` before a parameter name to tell Python that it should accept a number of keyword arguments and store them as a dictionary where the keys are the parameter name and the values are the arguments.\n",
    "\n",
    "Let's run an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def total_fruits(**kwargs):\n",
    "    print(kwargs, type(kwargs))\n",
    "\n",
    "\n",
    "total_fruits(banana=5, mango=7, apple=8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code above a dictionary of key and value pairs corresponding to the keyword arguments is printed. We passed three keyword arguments and each key corresponds to the name given to the keyword argument and the value corresponds to the argument itself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, create a function that accepts any number of keyword arguments, we want to pass course names and the number of students. The function should print out the course name and the number of students for example `Anatomy - 10 students`. We should be able to pass as many keyword arguments as possible. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in functions \n",
    "\n",
    "We've come across many of the commest built-in functions before. Python has over 71 built-in functions with only 44 technically being functions.\n",
    "\n",
    "We've covered most of the common functions. In this section, we'll cover a couple more that get overlooked. It is better to cover the functions commonly used slowly rather than learn them all, there are many you may never use.\n",
    "\n",
    "### sum\n",
    "\n",
    "The sum function takes an iterable of numbers and returns the sum of those numbers\n",
    "\n",
    "For example, run the snippet below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "courseNumbers = [10,5,2,5,1]\n",
    "sum(courseNumbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, create a list of numbers and find the total."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### min and max\n",
    "\n",
    "The min and max return the minimum and maximum values of an iterable. `max` and `min` require the argument passed to it is an orderable data type like a list.\n",
    "\n",
    "For example, run the snippets below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [2, 1, 3, 4, 7, 11, 18]\n",
    "min(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [2, 1, 3, 4, 7, 11, 18]\n",
    "max(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, create a list of numbers and find the maxium and minimum values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sorted\n",
    "\n",
    "The sorted function takes any iterable and returns a new list of all values in sorted order. \n",
    "\n",
    "The sorted function accepts two arguments, the iterable and reverse options. The difference between the `list.sort` method and `sorted` is that `sorted` can work on other data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,8,2,13,5,3,1]\n",
    "sorted(numbers, reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_numbers = {10, 2, 3, 9} # for example, sorted() works with sets\n",
    "sorted(set_numbers, reverse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modules are a tool we use to break up the code into multiple files in Python. When you create a file in Python you are making a Python module. \n",
    "\n",
    "The reasons for using modules in larger applications are as follows:\n",
    "\n",
    "1. Reusability - Functions defined in one module can be used elsewhere\n",
    "2. Maintability - Splitting code into a module enforces a boundary between problems that the code solve. \n",
    "3. Readability - Having small modules of code is much easier to understand and change\n",
    "\n",
    "Using code that others have created to solve problems is a large part of programming which you will gain experience in this course with helpful packages to do data science for example.\n",
    "\n",
    "To use code from different files you can import modules and the code within them. Its also possible to import modules from Python (like packages for randomising numbers) or a third-party package (NumPy or Pandas). \n",
    "\n",
    "A Python file that's meant to be imported by other Python files is called a **module**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing a whole module\n",
    "\n",
    "Python has a load of different modules called the [Python standard library](https://docs.python.org/3/library/)\n",
    "Let's import the `Math` module from the standard library.\n",
    "\n",
    "To import any module whether that is your own code or someone else's code we use the `import` keyword.\n",
    "\n",
    "Run the snippet of code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This snippet prints out text that describes the module. We call this a **module object** and this object has attributes that we can use specific functions or constants.\n",
    "\n",
    "To specify an attribute we use a dot and the function name afterwards. Run the code snippet below to see the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "math.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we import the math module. We access the attribute `pi` on the `math` module object. This returns the constant `pi`.\n",
    "\n",
    "The math library has a load of functions that we can use that don't come as part of a specific data type. For example, taking the square root of a number. \n",
    "\n",
    "Run the snippet below to see to use functions within a module object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "math.sqrt(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This outputs `5.0`, we import the math module and then use the dot notation to access the `sqrt` function. We pass the argument `25` and `sqrt` functions return the result specified."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's a built-in Python module called `random`. Within this module there is a function called `randint()`, it has two parameters `start` and `end`, we can pass integers as arguments and the function returns a random value between those two numbers.\n",
    "\n",
    "In the cell below, import the random module and return a random number between 5 and 25."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Module Search Path\n",
    "\n",
    "When Python executes an import statement it searches for the file. Lets take the example above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example Python searches for a file named `math.py` in three places:\n",
    "\n",
    "1. In `sys.modules`  - a builtin cache of all modules currently imported (sys is a built-in python package that provides helpful variables and functions to manipulate the running python environment)\n",
    "2. Built-in modules that are already installed with Python\n",
    "3. The folders that are set within `sys.path` (installation dependant folders) which will have the current directory where Python is currently running from.\n",
    "\n",
    "When Python finds a module, it binds the name of the module to the local scope of the file. This means in the example above `math` is now defined in the file without throwing an error.\n",
    "\n",
    "If a module is not found, python will throw an `ModuleNotFoundError`.\n",
    "\n",
    "To make you're files available to others, have the file within the same place python is being run from (You wont need to worry about this much in Jupyter Notebooks)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Importing specific module elements\n",
    "\n",
    "For importing functions from the math module above you'll have to add `math.` to everything in the code which creates a lot of duplication. \n",
    "\n",
    "To make it easier to work with specific functions/attributes within modules we can import specific attributes using the `from` keyword to remove the need to keep typing `math.` for example in our code. \n",
    "\n",
    "Run the cell below to see how this works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "sqrt(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this code snippet, the `from` keyword tells Python we want to import something specific from a module. We can then specify what module from we want after the `from` keyword.\n",
    "\n",
    "We use the `import` keyword after we specify which module we want to import from to specify the function.\n",
    "\n",
    "The return value is the same, but now we have access to `sqrt` directly.\n",
    "\n",
    "To import multiple things from a module, we can use the comma to do so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt, pi\n",
    "sqrt(pi**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we return the value of `pi` , but we specified the `pi` attribute and the function `sqrt`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing a module under a different name\n",
    "\n",
    "We can import a module under a different name when sometimes the module name is quite large and we don't want to keep repeating ourselves. \n",
    "\n",
    "When we import a whole module, we can use the `as` keyword afterwards and specify a name to change the module name to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m\n",
    "m.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The return value is `pi` however using the `as` keyword we have shortened the module name `math` to `m`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a previous section we imported the `random` module. In the cell below, import the function `randint` from this module and rename it to `randomInt`. Then use this function to output a random number between 1 and 100. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import your own modules\n",
    "\n",
    "We mentioned above you can import modules from other people's code. But the other important aspect of modules is that you can import code you create yourself. \n",
    "\n",
    "If you have two files called `numbers.py` and `mathutils.py` in the same directory. and we want to import the `mathutil` module into `numbers.py`  We can simply use the import keyword and specify `mathutil`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "# Numbers.py\n",
    "import mathutil\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Styles of Imports\n",
    "\n",
    "Within PEP8 the style guide for Python it comes with some pointers on how to group your imports.\n",
    "\n",
    "1. Imports should be at the top of the file\n",
    "2. Imports should be seperate into three different groups\n",
    "\t1. Standard Library imports (built-in modules)\n",
    "\t2. Third party imports (modules installed but do not belong to your code)\n",
    "\t3. Local application imports\n",
    "3. Each group of imports should be seperated by a single line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "# Standard Library imports\n",
    "import os\n",
    "import json\n",
    "\n",
    "# Third party Imports\n",
    "from flask import flask\n",
    "\n",
    "# Application Imports\n",
    "from local_module import local_function\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a function that returns the first element of an input list. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first(['Python','Data Science','Machine Learning']) # returns 'Python'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Write a function that returns the last element of an input list. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "last(['Python','Data Science','Machine Learning']) # returns 'Machine Learning'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. The destinations list contains a list of travel destinations. Write a function that checks whether or not a particular destination is included within destinations.\n",
    "\n",
    "For example: When checking whether 'Barcelona' is contained in destinations, the expected output is true, whereas the expected output for 'Nashville' is false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "destinations = ['Prague', 'London', 'Sydney', 'Belfast', 'Rome',\n",
    "  'Aruba', 'Paris', 'Bora Bora', 'Barcelona', 'Rio de Janeiro',\n",
    "  'Marrakesh', 'New York City']\n",
    "\n",
    "contains('Barcelona', destinations); # true\n",
    "contains('Nashville', destinations); # false"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Create a function that calculates a person's body mass index (BMI). It should take two parameters: someone's height (in cm) and weight (in kg). \n",
    "\n",
    "The formula for calculating the BMI is as follows:\n",
    "\n",
    "Note that formula requires a height in meters, but the function takes the height in centimeters (1 meter is equivalent to 100 centimeters).\n",
    "\n",
    "Return the result as a string rounded to two decimals. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bmi = weight_in_kilograms / height_in_meters**2\n",
    "calculateBMI(180, 80) # \"24.69\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Create a function `remove_last_char` that takes a string as an argument, and returns the string without the last character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "remove_last_char('ciao!') # 'ciao'\n",
    "remove_last_char('hello') # 'hell'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Write a function that takes two list arguments, each containing a list of numbers, and returns a new list containing the products of all combinations of number pairs that exist between the two list. \n",
    "\n",
    "The returned list should be sorted in ascending numerical order.\n",
    "\n",
    "You may assume that neither argument will be an empty list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multiplyAllPairs([2,4], [4, 3, 1, 2]) # [2, 4, 4, 6, 8, 8, 12, 16]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Write a function that takes two strings as arguments, determines the length of the two strings, and then returns the result of concatenating the shorter string, the longer string, and the shorter string once again. You may assume that the strings are of different lengths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shortLongShort('abc', 'defgh') # \"abcdefghabc\"\n",
    "shortLongShort('abcde', 'fgh') # \"fghabcdefgh\"\n",
    "shortLongShort('', 'xyz') # \"xyz\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Write a function that computes the sum of all numbers between 1 and some other number, inclusive, that are multiples of 3 or 5. For instance, if the supplied number is 20, the result should be 98 (3 + 5 + 6 + 9 + 10 + 12 + 15 + 18 + 20).\n",
    "\n",
    "You may assume that the number passed in is an integer greater than 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multisum(3)       # 3\n",
    "multisum(5)       # 8\n",
    "multisum(10)     # 33\n",
    "multisum(1000)    # 234168"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. Write a function that takes a string, doubles every character in the string, and returns the result as a new string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "repeater('Hello');       # \"HHeelllloo\"\n",
    "repeater('Good job!');   # \"GGoooodd  jjoobb!!\"\n",
    "repeater('');            #  \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check your understanding\n",
    "\n",
    "1. What is a parameter ? \n",
    "2. What is an argument ?\n",
    "3. Can you give an example of a function call ?\n",
    "4. What is a module ?\n",
    "5. What is the difference between a keyword argument and a positional argument ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "In this exercise we should have a better understanding on how to use functions and modules to try and make code more readable and maintable. Its important to make sure your functions are small and do one task. Providing a definition comment of a function will help you think about whether the function is doing many things. \n",
    "\n",
    "Modules and Packages are used in applications that grow to longer than a few files of code. They help keep it maintable, readable and reusable. \n",
    "\n",
    "When you're writing your code think about the one task the lines of code you're writing is doing. Can we put this into a function ? It's better to have 5 small functions than one long function.\n",
    "\n",
    "Consider creating modules when your file is getting larger and harder to reason about the code with lots of functions. Typically speaking a module should have functions that are related together so consider this when you're reading your code. \n",
    "\n",
    "When you start learning to code, you wont necessarily think in terms of functions and modules and thats okay. You can always refactor a long piece of code and break it down into smaller pieces. Start to structure the code gradually, and keep making sure your code still works after you write a function or a module. Always change your code in small steps and rerun it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feedback \n",
    "\n",
    "Fill out the form below and we'll provide feedback on your code.\n",
    "\n",
    "**Any feedback on the exercise? Any questions? Want feedback on your code? Please fill out the form [here](https://docs.google.com/forms/d/e/1FAIpQLSdoOjVom8YKf11LxJ_bWN40afFMsWcoJ-xOrKhMbfBzgxTS9A/viewform)**."
   ]
  }
 ],
 "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}