part_one/1-functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "One of the core principles of any programming language is, **\"Don't Repeat Yourself\"**. \n",
    "\n",
    "If you have an action that should occur many times, you can define that action once and then call that code whenever you need to carry out that action.\n",
    "\n",
    "We are already repeating ourselves in our code, so this is a good time to introduce simple functions. Functions mean less work for us as programmers, and effective use of functions results in code that is less error-prone."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we have only been using the functions that come with Python, but it is also possible to **add new functions**. \n",
    "\n",
    "A **function definition** specifies the name of a new function and the sequence of statements that execute when the function is called.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<a name='general_syntax'></a>General Syntax\n",
    "---\n",
    "A general function looks something like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "# Let's define a function.\n",
    "def function_name(argument_1, argument_2):\n",
    "    # Do whatever we want this function to do,\n",
    "    #  using argument_1 and argument_2\n",
    "\n",
    "# Use function_name to call the function.\n",
    "function_name(value_1, value_2)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This code will not run, but it shows how functions are used in general."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- **Defining a function**\n",
    "    - Give the keyword `def`, which tells Python that you are about to *define* a function.\n",
    "    - Give your function a name. A variable name tells you what kind of value the variable contains; a function name should tell you what the function does.\n",
    "    - Give names for each value the function needs in order to do its work.\n",
    "        - These are called the function's *arguments*.\n",
    "    - Make sure the function definition line ends with a colon.\n",
    "    - Inside the function, write whatever code you need to make the function do its work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- **Calling (i.e. _Using_ ) your function**\n",
    "    - To *call* your function, write its name followed by parentheses.\n",
    "    - Inside the parentheses, give the values you want the function to work with."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<a name='examples'></a>Basic Examples\n",
    "===\n",
    "For a simple first example, we will look at a program that executes the sum of two numbers `[1]`\n",
    "\n",
    "Let's look at the example, and then try to understand the code. \n",
    "\n",
    "First we will look at a version of this program as we would have written without using functions.\n",
    "\n",
    "<span class=\"fn\"><i>[1]</i> *I know*, I will think of better examples later. However even simple examples may lead to interesting discussions ;) [2]</span>\n",
    "<span class=\"fn\"><i>[2]</i> We won't end up being re-implementing the calculator, I promise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2+2 is equal to:  4\n",
      "3+2 is equal to:  5\n",
      "3+3 is equal to:  6\n"
     ]
    }
   ],
   "source": [
    "print(\"2+2 is equal to: \", 2+2)\n",
    "print(\"3+2 is equal to: \", 3+2)\n",
    "print(\"3+3 is equal to: \", 3+3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Functions take repeated code, put it in one place, and then you call that code when you want to use it. Here's what the same program looks like with a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2+2 is equal to:  4\n",
      "3+2 is equal to:  5\n",
      "3+3 is equal to:  6\n"
     ]
    }
   ],
   "source": [
    "# Here is the definition of function\n",
    "def sum(n: int, m: int):\n",
    "    print(f\"{n}+{m} is equal to: \", n+m)\n",
    "    # Note: here we are using f-strings\n",
    "    # Alternatively, we could've written\n",
    "    # print(\"{}+{} is equal to: \".format(n, m), n+m)\n",
    "\n",
    "sum(2, 2)\n",
    "sum(3, 2)\n",
    "sum(3, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In our original code, each pair of print statements was run three times, and the only difference was the two numbers we were summing up. \n",
    "\n",
    "When you see repetition like this, you can usually make your program more efficient by defining a **function**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The keyword `def` tells Python that we are about to define a function. \n",
    "\n",
    "We give our function a name, `sum` in this case. \n",
    "\n",
    "A variable's name should tell us what kind of information it holds; a function's name should tell us what the variable does.  \n",
    "\n",
    "We then put parentheses. \n",
    "\n",
    "Inside these parenthese we assign a name for any **parameter** the function will need in order to do its job. \n",
    "\n",
    "In this case the function will need two numbers sum. The variables `n` and `m` will hold the value that is passed into the function `sum`.\n",
    "\n",
    "**Note:**\n",
    "\n",
    "The function signature \n",
    "\n",
    "```python\n",
    "def sum(n: int, m: int):\n",
    "```\n",
    "\n",
    "contains **type-hints annotations** ([doc](https://www.python.org/dev/peps/pep-0484/#rationale-and-goals)). \n",
    "\n",
    "This is for **documentation purposes** only, not to confuse with **static type** assignments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Warm up Exercise\n",
    "\n",
    "###### Ex. 1\n",
    "\n",
    "Try to re-implement the previous function replacing the f-string with the format alternative. \n",
    "\n",
    "**Note**: it is vital that you **do not** copy&paste the code, but you re-write the whole code again, instead. This will help you in bearing in mind what you are doing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "###### Side note \n",
    "\n",
    "From now on, we will try to also levarage on VSCode [Live Share Extension](https://code.visualstudio.com/blogs/2017/11/15/live-share).\n",
    "\n",
    "This will be mostly for the hands-on parts, and exercises.\n",
    "\n",
    "So, in these cases you are supposed to follow the five steps reported below:\n",
    "\n",
    "1. Open your VS Code Editor on your local machine\n",
    "2. Join the live session (link will be provided live)\n",
    "3. Create a folder with your name\n",
    "2. Create a new Python file called the way you fancy the most (e.g. `functions.py` in this case)\n",
    "3. Write the instructions in the file (Python module)\n",
    "4. Save the file\n",
    "5. **Execute** your code on your local machine. \n",
    "    - To execute, prompt in a terminal: `$ python functions.py` (for example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Ex. 2\n",
    "\n",
    "Try to call the function with two arguments of type `string`, and see what happens."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### A common error\n",
    "A function must be defined before you use it in your program. For example, putting the function at the end of the program would **not** simply work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "\n",
    "sum(2, 2)\n",
    "sum(3, 2)\n",
    "sum(3, 3)\n",
    "\n",
    "def sum(n: int, m: int):\n",
    "    print(f\"{n}+{m} is equal to: \", n+m)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "On the first line we ask Python to run the function `sum`, but Python does not yet know how to do this function. We define our functions at the beginning of our programs, and then we can use them when we need to."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Advantages of using functions\n",
    "You might be able to see some advantages of using functions, through this example:\n",
    "\n",
    "- We write a set of instructions once. We save some work in this simple example, and we save even more work in larger programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- When our function works, we don't have to worry about that code anymore. Every time you repeat code in your program, you introduce an opportunity to make a mistake. Writing a function means there is one place to fix mistakes, and when those bugs are fixed, we can be confident that this function will continue to work correctly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- We can modify our function's behavior, and that change takes effect every time the function is called. This is much better than deciding we need some new behavior, and then having to change code in many different places in our program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<a name='return_value'></a>Returning a Value\n",
    "---\n",
    "Each function you create can **return** a value. \n",
    "\n",
    "This can be in addition to the primary work the function does, or it can be the function's main job. \n",
    "\n",
    "The following function takes in a number, and returns the corresponding **english word** of that number:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "def get_number_word(number):\n",
    "    # Takes in a numerical value, and returns\n",
    "    #  the word corresponding to that number.\n",
    "    if number == 1:\n",
    "        return 'one'\n",
    "    elif number == 2:\n",
    "        return 'two'\n",
    "    elif number == 3:\n",
    "        return 'three'\n",
    "    # ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function be like:\n",
    "\n",
    "<blockquote class=\"twitter-tweet\"><p lang=\"en\" dir=\"ltr\">God I wish there was an easier way to do this <a href=\"https://t.co/8UrBNKdTRW\">pic.twitter.com/8UrBNKdTRW</a></p>&mdash; Kat Maddox (@ctrlshifti) <a href=\"https://twitter.com/ctrlshifti/status/1288745146759000064?ref_src=twsrc%5Etfw\">July 30, 2020</a></blockquote> <script async src=\"https://platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Better `encapsulation`\n",
    "\n",
    "Let's try to re-work our previous example by using the `return` statement.\n",
    "This will lead also to better **encapsulation**, namely **you had one job!** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10+2 is equal to:  12\n"
     ]
    }
   ],
   "source": [
    "def sum(n: int, m: int) -> int: \n",
    "    return n+m\n",
    "\n",
    "print(\"10+2 is equal to: \", sum(10, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Few Notes:\n",
    "\n",
    "1. The function signature now also includes a _type-hint_ for the return type, i.e. `int`:\n",
    "\n",
    "```python\n",
    "def sum(n: int, m: int) -> int:\n",
    "```\n",
    "\n",
    "The `->` sign refers to the `type` of the **returned value**.\n",
    "\n",
    "2. This implementation looks quite similar to the previsou one, with the only (BIG) difference that the definition of function's responsibility is better defined in this case:\n",
    "\n",
    "    - The function indeed implements the **sum of two numbers**, rather than **printing** the sum of two numbers! Can you see the difference?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Ex 3. Not that kind of calculator\n",
    "\n",
    "Try to implement a new function called `multiply` which implements the multiplication of two numbers.\n",
    "\n",
    "Try to run the function with the following arguments:\n",
    "\n",
    "```python\n",
    "multiply(3, 3)\n",
    "multiply(\"2\", 3)\n",
    "multiply(2, \"3\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Ex 3.1 (Optional) \n",
    "\n",
    "Implement also the `substract` function and test it using the same input."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Getting along with functions \n",
    "\n",
    "There is much more to learn about functions, but we will get to those details later. For now, feel free to use functions whenever you find yourself writing the same code several times in a program. Some of the things you will learn when we focus on functions:\n",
    "\n",
    "- How to give the arguments in your function default values.\n",
    "- How to let your functions accept different numbers of arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In previous sections, we learnt the most bare-boned versions of functions. \n",
    "\n",
    "Now we will learn more general concepts about functions, like how to handle parameters in functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Default argument values\n",
    "\n",
    "When we first introduced functions, we started with this example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "def sum(n: int, m: int):\n",
    "    print(f\"{n}+{m} is equal to: \", n+m)\n",
    "    # Note: here we are using f-strings\n",
    "    # Alternatively, we could've written\n",
    "    # print(\"{}+{} is equal to: \".format(n, m), n+m)\n",
    "\n",
    "sum(2, 2)\n",
    "sum(3, 2)\n",
    "sum(3, 3)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This function works fine, but it fails if you don't pass in **all** the paramenters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "sum() missing 1 required positional argument: 'm'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-2e85d758315d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\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: sum() missing 1 required positional argument: 'm'"
     ]
    }
   ],
   "source": [
    "sum(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "That makes sense; the function needs to have **both** `n` and `m` in order to do its work, so without either the two, it stucks.\n",
    "\n",
    "If you want your function to do something by **default**, to cover the case when some information is not (intentionally) provided, you can do so by giving your arguments `default values`. \n",
    "\n",
    "The default values of parameters are specified in function signature:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def sum(n: int, m: int = 0):\n",
    "    \"\"\"Implements the sum of two numbers, n and m.\n",
    "    If not provided, m=0 by default so implementing the \n",
    "    identify function.\n",
    "    \"\"\"\n",
    "    return n+m\n",
    "\n",
    "print(\"This won't fail, assuming 'm=0' -> sum(5) =\", sum(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This is particularly useful when you have a number of arguments in your function, and some of those arguments almost always have the same value. This allows people who use the function to only specify the values that are unique to their use of the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Ex 4. Identity for Binary Operators\n",
    "\n",
    "Even if it shouldn't be allowed to define a binary operator like `sum` and `multiply` with one argument, let's assume that our requirement is to implement the identity for those operators when conditions apply.\n",
    "\n",
    "Therefore, please implement the `identity` function for both `sum` and `multiply` in case either `n` or `m` are not provided in function call."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Positional Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Much of what you will have to learn about using functions involves how to pass values from your calling statement to the function itself. \n",
    "\n",
    "The example we just looked at is pretty simple, and only makes sense with numbers.\n",
    "\n",
    "Let's try to exit a bit the confort zone and let's try to implement a more \"sophisticated\" function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### String Padding\n",
    "\n",
    "We want to implement a `pad` function which pads two input strings with a given pad character.\n",
    "\n",
    "Example:\n",
    "\n",
    "```python\n",
    ">>> pad(\"Python\", \"language\", \"-\")\n",
    "'Python-language'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def pad(w1: str, w2: str, p: str) -> str:\n",
    "    \"\"\"String padding leveraging on f-strings\n",
    "    \n",
    "    Paramenters\n",
    "    -----------\n",
    "    w1: str\n",
    "        First word\n",
    "    w2: str\n",
    "        Second word\n",
    "    p: str\n",
    "        Padding character or string\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "        The two strings w1 and w2 padded with p\n",
    "    \"\"\"\n",
    "    return f\"{w1}{p}{w2}\"\n",
    "\n",
    "\n",
    "pad(\"Python\", \"language\", \"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The arguments in this function are `w1`, `w1`, and `p` for the padding. \n",
    "This function implements also the bare bones of a [docstring](https://www.python.org/dev/peps/pep-0257/).\n",
    "\n",
    "\n",
    "Whenever we are calling a function like \n",
    "\n",
    "```python\n",
    "    pad(\"Python\", \"language\", \"-\")\n",
    "```\n",
    "we are leveraging on **Positional Arguments**: Python matches the first value `\"Valerio\"` with the first argument, `\"Maggio\"` as the second `w2` argument, and so on.\n",
    "\n",
    "This is pretty straightforward, but it means we have to make sure to get the arguments in the right order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If we mess up the order, we get nonsense results or (sometimes) errors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pad(\"Python\", \"-\", \"language\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Keyword arguments\n",
    "\n",
    "Python also allows for another syntax called *keyword arguments*. \n",
    "\n",
    "In this case, we can give the arguments in any order when we **call the function**, as long as we use the name of the arguments in our calling statement. \n",
    "\n",
    "Here is how the previous code can be made to work using keyword arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "pad(w1=\"Python\", p=\"-\", w2=\"language\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This works, because Python does not have to match values to arguments by position, but it matches values to corresponding paramenters by name. \n",
    "\n",
    "**This also** makes the code more readable when we have to deal with functions with lots of parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Mixing positional and keyword arguments\n",
    "\n",
    "It can make good sense sometimes to mix positional and keyword arguments. \n",
    "\n",
    "In our previous example, we can expect this function to always take in a first name and a last name. \n",
    "\n",
    "Before we start mixing positional and keyword arguments, let's add another piece of information (i.e. **requirements**).\n",
    "\n",
    "We want to modify the `pad` function by also specifying an exact **number of times** we want the padding character to be inserted; `1` time by default.\n",
    "\n",
    "The function stub would look like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "def pad(w1: str, w2: str, p: str, times: int = 1):\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### I need your help:\n",
    "\n",
    "Could you please suggest a possible implementation for this function?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### When you're done\n",
    "\n",
    "Try to call the new function with the following input:\n",
    "\n",
    "```python\n",
    ">>> pad(\"Python\", \"language\", times=2, p=\"-\")\n",
    ">>> pad(\"Python\", \"language\", p=\"//\")\n",
    ">>> pad(w1=\"Python\", w2=\"language\", p=\" \")\n",
    ">>> pad(w2=\"Python\", \"language\", times=2, p=\"-\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Before we conclude...**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The \"main\" function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The last function in a program like this is **usually** called `main` and it\n",
    "runs the program using other functions. \n",
    "\n",
    "**Please note** that this is just a code convention, it is **not** a rule.\n",
    "\n",
    "So, imagine that we defined a function called `main`:\n",
    "\n",
    "```python\n",
    "def main():\n",
    "    ...\n",
    "```\n",
    "\n",
    "In order to instruct the interpreter to properly define a **main** section \n",
    "in our Python module, we need to add the following two lines at the end of the \n",
    "file:\n",
    "\n",
    "```python\n",
    "if __name__ == '__main__':\n",
    "    main()\n",
    "```\n",
    "\n",
    "The `__name__` variable is set differently depending on how we run the\n",
    "file, and it's `'__main__'` when we run the file directly instead of\n",
    "importing. \n",
    "\n",
    "So if we run the file, the code will enter the main section and will execute; otherwise (in the case in which we import the module) we can still run the functions one by one\n",
    "but the **main section** won't be executed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# More than one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Differently from other programming languages, in Python a function may return **more** than one value. For example:\n",
    "\n",
    "```python \n",
    "\n",
    "def return_two_values():\n",
    "    return 1, 2\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "When called, this function will return **two** values (i.e. `1` and `2`, respectively). So, if we want to get those values, we can do:\n",
    "\n",
    "```python \n",
    "\n",
    ">>> values = return_two_values()\n",
    ">>> print(values)\n",
    "(1, 2)\n",
    "```\n",
    "\n",
    "In this case, the `type` of the variable `values` will be automagically mapped to a **tuple** (more on this in the next section)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Moreover**, another possibility is to take the two return values separately in **two** different variables like this:\n",
    "\n",
    "```python \n",
    ">>> first, second = return_two_values()\n",
    ">>> print(first)\n",
    "1\n",
    ">>> print(second)\n",
    "2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This particular operation of assigning \"at the same time\" values to more-than-one variables is called **tuple unpacking** (more on this in the section about tuples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "There are **many** built-in functions in Python returning more than one value. Perhaps, the most common one is `enumerate` which is \n",
    "used to `enumerate` a sequence (e.g. `list`, `tuple`...)"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}