DS109-Python/DS109-L5-Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50e6ddbb-52d3-4a02-9b69-100a4181e3b0",
   "metadata": {},
   "source": [
    "# DS109 Python : Lesson Five Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bd4bfc-9b15-4b80-87b4-b8b60eb56371",
   "metadata": {},
   "source": [
    "### Table of Contents <a class=\"anchor\" id=\"DS109L5_toc\"></a>\n",
    "\n",
    "* [Table of Contents](#DS109L5_toc)\n",
    "    * [Page 1 - Overview and Setup](#DS109L5_page_1)\n",
    "    * [Page 2 - What Is a Function?](#DS109L5_page_2)\n",
    "    * [Page 3 - Providing Data to a Function](#DS109L5_page_3)\n",
    "    * [Page 4 - Returning Data From a Function](#DS109L5_page_4)\n",
    "    * [Page 5 - Local Variables and Scope](#DS109L5_page_5)\n",
    "    * [Page 6 - Functions Activity Part 1](#DS109L5_page_6)\n",
    "    * [Page 7 - Functions Activity Part 2](#DS109L5_page_7)\n",
    "    * [Page 8 - Unnamed, Anonymous Functions](#DS109L5_page_8)\n",
    "    * [Page 9 - Operations That Can Be Performed on Collections](#DS109L5_page_9)\n",
    "    * [Page 10 - Lambda Activity Part 1](#DS109L5_page_10)\n",
    "    * [Page 11 - Lambda Activity Part 2](#DS109L5_page_11)\n",
    "    * [Page 12 - Lesson 5 Practice Hands-On](#DS109L5_page_12)\n",
    "    * [Page 13 - Lesson 5 Practice Hands-On Solution](#DS109L5_page_13)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5a8c65-ed48-4354-a257-e01b0fd733d4",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 1 - Overview of this Module<a class=\"anchor\" id=\"DS109L5_page_1\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "594bded0-eedb-4487-8cf2-cfb69ca07ef1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/238449182\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x7f9948a49490>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Functions\n",
    "VimeoVideo('238449182', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6ad526-95fa-43c4-bc43-1fe807708ed3",
   "metadata": {},
   "source": [
    "Looking back at earlier lessons, do you remember operations such as `print()`, `len()`, and `range()`? From time to time, they were referred to as functions, and you were informed that they would be covered later. Well, here you are!\n",
    "\n",
    "The aforementioned operations that you can now, correctly, call _functions_, are three of several built-in functions that are available to you through the Python library. However, you can also create your own functions. In fact, you'll find yourself building functions constantly as a developer.\n",
    "\n",
    "In this lesson, you'll learn about the makeup of a function, how to create and use them. You'll also learn how data is passed back and forth between the function caller and the function itself.\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>You may want to watch this <a href=\"https://vimeo.com/432014267\"> recorded live workshop </a> that goes over the material on functions in this lesson. </p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "## Setup\n",
    "\n",
    "1. First, open up your command prompt (Windows) or your terminal (Mac/Linux)\n",
    "    - For Windows, navigate to your search bar in the bottom left hand corner. Type in `Command Prompt` and it should pop up. Click on `Command Prompt` and a separate window should appear on your screen.\n",
    "    - For Mac, press `command` and the space bar at the same time. Type in `terminal` and press `enter`. A separate Terminal window will pop up.\n",
    "2. Now that you are in your Command Prompt/Terminal, run the following command:\n",
    "    ```text\n",
    "    cd desktop\n",
    "    ```\n",
    "3. Next, move your command prompt/terminal's location to the new `python_course` you just created by running the following:\n",
    "    ```text\n",
    "    cd python_course\n",
    "    ```\n",
    "4. Create a _new_ directory within the `python_course` directory. This new folder is the project you will be working in for this lesson. Run the following:\n",
    "    ```text\n",
    "    mkdir lesson_five\n",
    "    ```\n",
    "5. Open up a new window in VSCode.\n",
    "6. The first thing you should see a Welcome page. You can close this window.\n",
    "7. Now, its time to open the `lesson_five` directory. Click on the \"Explorer\" button on the left-hand side of the VSCode window.\n",
    "8. You will now see a button that says `Open Folder`, as shown below. Click this button.\n",
    "9. A new window will open that will allow you to search for files and folders. Locate the `python_course` folder you just created on your Desktop. Click on that folder and then locate the `lesson_five` folder. Select the `lesson_five` directory and click the `Open` button.\n",
    "10. Create a new file named `main.py` by one of the following three ways:\n",
    "    - To the right of __LESSON_FIVE__ in the EXPLORER is a button that looks like a piece of paper with a plus symbol in its top-left corner. If you hover your mouse over this button for a moment, a popup will appear indicating that this button will create a new file.\n",
    "    - Choose `File > New File` from the app's menu.\n",
    "    - Press `Control + N` in Windows or `Command + N` on a Mac (the plus means \"and at the same time\").\n",
    "\n",
    "Once the `main.py` file is created, you are ready to go! As you work through this lesson, add the code examples into your project so you can see the output yourself. Remember, to see the output within the VSCode terminal, right-click within your file and choose \"Run Python File in Terminal\".\n",
    "\n",
    "The creation of this new project is for you to practice your new skills. It is highly recommended that you add the code from this lesson into your `lesson_five` project as you learn it. As you are going through this lesson and adding code to your project, you may find it helpful to include `comments` with a brief sentence explaining what is going on in the code. That way, you will have an easy reference to the topics explained in this lesson. Happy coding!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7990ac7a-5a2f-4744-af14-1b7e385ea484",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 2 - What Is a Function?<a class=\"anchor\" id=\"DS109L5_page_2\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612429df-e4ef-4d85-8460-5bc8914079c3",
   "metadata": {},
   "source": [
    "# What Is a Function?\n",
    "\n",
    "A `function` is a re-usable block of code that, when called, performs a series of operations that are related to a specific task. A function is given a name that you use elsewhere when you wish to perform that series of operations. Using functions improves code readability and decreases development time. The use of functions also reduces maintenance efforts, since logic is grouped into functions instead of being littered throughout the application. If you need to make a change, it's much easier to change one location instead of 50.\n",
    "\n",
    "Take a look at the code below which defines a function. Each piece will be discussed:\n",
    "\n",
    "```python\n",
    "def greeting():\n",
    "    \"\"\"This function prints a greeting\"\"\"\n",
    "    print(\"Hello!\")\n",
    "\n",
    "greeting()\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "Hello!\n",
    "```\n",
    "\n",
    "When _defining_ a function, the first thing you need is the appropriate Python keyword: `def`. This keyword tells the Python interpreter that what follows is a function.\n",
    "\n",
    "```python\n",
    "def\n",
    "```\n",
    "\n",
    "The name of the function follows the `def` keyword. The name can be anything you'd like, but you want to ensure that it makes sense. Above, the function name is `greeting`. Function naming conventions and rules are similar to those for variable names.\n",
    "\n",
    "```python\n",
    "def greeting\n",
    "```\n",
    "\n",
    "After the function's name, you'll find parentheses `()`. When you need to provide information for the function, you'll find _parameters_ inside of the parentheses. Parameters will be discussed shortly, but the above function has none, so there's nothing between each parenthesis.\n",
    "\n",
    "```python\n",
    "def greeting()\n",
    "```\n",
    "\n",
    "Like `for` and `while` loops, as well as `if` and `else`, when defining a function the first line must end with a colon `:`.\n",
    "\n",
    "```python\n",
    "def greeting():\n",
    "```\n",
    "\n",
    "All of the Python code that will be executed when the function is used must be indented, as you can see above. This is no different that an `if` block or `for` loop. The indentation is maintained until the end of the function's definition.\n",
    "\n",
    "The first line of code of the function is called a `docstring` (documentation string). A _docstring_ is used to specify the purpose of the function. A function's docstring is defined by including a _string literal_ as the first statement in the function's definition. A _string literal_ is text enclosed within triple-quotes, and they can be a single line or multiple lines. Although it is not _required_, all functions _should_ have a docstring.\n",
    "\n",
    "```python\n",
    "def greeting():\n",
    "    \"\"\"This function prints a greeting\"\"\"\n",
    "```\n",
    "\n",
    "The final line of code of the `greeting` function is a call to the `print()` function to print out the greeting. Other than the docstring, this represents the _body_ of the function. The body can contain as many operations as necessary, although the function below only has one.\n",
    "\n",
    "```python\n",
    "def greeting():\n",
    "    \"\"\"This function prints a greeting\"\"\"\n",
    "    print(\"Hello!\")\n",
    "\n",
    "greeting()\n",
    "```\n",
    "\n",
    "Below the function definition, you'll find the line of code that _calls_ the function: `greeting()`. When you define a function, like how `greeting` was defined above, the code is not executed unless it is called, or invoked.\n",
    "\n",
    "And there you have it! A function!\n",
    "\n",
    "Next, you'll learn about how data is passed between the caller and the function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "86712c97-052f-4679-902d-b3d28288bb2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting():\n",
    "    \"\"\"This function prints a greeting\"\"\"\n",
    "    print(\"Hello!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4aa3a160-159b-41d3-9c9c-641d1e13929f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "greeting()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c97cf3a2-82c0-41b9-ae8e-e5f90949e6fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from DS_Students import MultipleChoice  \n",
    "except:\n",
    "    !pip install DS_Students\n",
    "    from DS_Students import MultipleChoice\n",
    "from ipynb.fs.full.DS109Questions import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8cb5a4ce-f09c-417d-83cb-cf99b8a4a6bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e1354d43249344fa86eafdbec1c4131b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), RadioButtons(layout=Layout(width='max-content'), options=(('A. True', 0), ('B. False'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d43782d7d23546ed9088c4c4ef348f88",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), RadioButtons(layout=Layout(width='max-content'), options=(('A. def', 0), ('B. func', …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a5e9c97cac89494bbf6d51954b89d680",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), RadioButtons(layout=Layout(width='max-content'), options=(('A. Function name', 0), ('…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L5P2Q1, L5P2Q2, L5P2Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832358fd-55fa-420a-8aa2-46fbf2097986",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 3 - Providing Data to a Function<a class=\"anchor\" id=\"DS109L5_page_3\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f564e3e7-3a7f-4936-b3a3-2e0a9ab78512",
   "metadata": {},
   "source": [
    "try:\n",
    "    display(L5P2Q1, L5P2Q2, L5P2Q3)\n",
    "except:\n",
    "    pass# Providing Data to a Function\n",
    "\n",
    "As you build functions, you'll find that in order for the function to perform its operations, it may require data. In the previous example, the `greeting` function did not require any data. However, below, you'll find a new function definition that does.\n",
    "\n",
    "```python\n",
    "def increment(value):\n",
    "    \"\"\"This function increments a value\"\"\"\n",
    "    print(\"Old value =\", value)\n",
    "    value += 1\n",
    "    print(\"New value =\", value)\n",
    "\n",
    "increment(10)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Old value = 10\n",
    "New value = 11\n",
    "```\n",
    "\n",
    "---\n",
    "## Function Parameters\n",
    "\n",
    "In the definition of the `increment` function above, you should see that there is now a variable name nestled between the parenthesis:\n",
    "\n",
    "```python\n",
    "def increment(value):\n",
    "```\n",
    "\n",
    "The `value` variable is called a `parameter` of the function. A function can have zero or more parameters, and the sequence of the parameters is your choice (although it will matter later).\n",
    "\n",
    "Inside of the function's definition, these parameters can be used like any other variable. However, if you change the value of the parameter, it will only remain changed within the function's definition. You'll learn more about this shortly.\n",
    "\n",
    "When a function has parameters, anytime that function is used, the parameters must be provided. The last line of the above sample code shows how the function is invoked and passed its required input.\n",
    "\n",
    "```python\n",
    "increment(10)\n",
    "```\n",
    "\n",
    "If a value for the parameter is left out of the call to the function, it will produce an error (NOTE: the `# ...` below means that the other code was left out in order to highlight the relevant code; you will see this from time-to-time in this course):\n",
    "\n",
    "```python\n",
    "# ...\n",
    "increment()\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Traceback (most recent call last):\n",
    "  File \"/Users/username/Desktop/my_Python/lesson_5.py\", line 7, in <module>\n",
    "    increment()\n",
    "TypeError: increment() missing 1 required positional argument: 'value'\n",
    "```\n",
    "\n",
    "As you can see above, the error was verify specific as to the problem:\n",
    "\n",
    "> TypeError: increment() missing 1 required positional argument: 'value'\n",
    "\n",
    "But, what is an argument?\n",
    "\n",
    "---\n",
    "\n",
    "## Arguments to a Function\n",
    "\n",
    "When a function requires input, its definition includes parameters, as you saw above. When you make use of the function by calling/invoking it, you must provide the required input. The data that you provide for each parameter is called an `argument`.\n",
    "\n",
    "The `increment` function had one parameter `value`:\n",
    "\n",
    "```python\n",
    "def increment(value):\n",
    "```\n",
    "\n",
    "In the call to `increment`, a single value `10` was provided: That is the _argument_.\n",
    "\n",
    "Take a look at another example (there is no need to try this code yourself):\n",
    "\n",
    "```python\n",
    "def my_function(how_many, of_what, it_tastes):\n",
    "    # do stuff\n",
    "```\n",
    "\n",
    "Above, the `my_function` definition includes three parameters: `how_many`, `of_what`, and `it_tastes`. Below is the code that calls the above function:\n",
    "\n",
    "```python\n",
    "my_function(10, 'apples', 'yummy')\n",
    "```\n",
    "\n",
    "The call to `my_function` includes three arguments &mdash; `10`, `'apples'`, and `'yummy'` &mdash; one for each parameter. `10` is the argument corresponding to the `how_many` parameter; `'apples'` is the argument corresponding to the `of_what` parameter; `'yummy'` is the argument corresponding to the `it_tastes` parameter.\n",
    "\n",
    "---\n",
    "## Optional Function Parameters\n",
    "\n",
    "Functions can have _optional_ parameters. This is accomplished by providing a default value for a parameter. To illustrate, take a look at the code below that modifies the `increment` function to take a second parameter named: `step_size`. The call to the function has also been modified to provide the required argument for the new parameter.\n",
    "\n",
    "```python\n",
    "def increment(value, step_size):\n",
    "    \"\"\"This function increments a value\"\"\"\n",
    "    print(\"Old value =\", value)\n",
    "    value += step_size\n",
    "    print(\"New value =\", value)\n",
    "\n",
    "increment(10, 5)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Old value = 10\n",
    "New value = 15\n",
    "```\n",
    "\n",
    "As you can see above, the `step_size` parameter is used as the amount to increment the value of `value`. Previously, it was incremented by 1; in this case, you can specifically set the step size (`2` is used in the example).\n",
    "\n",
    "To illustrate an optional parameter, the `step_size` parameter is given a default value using the assignment operator `=` and the default value. Below, the default value of the `step_size` parameter is `1`.\n",
    "\n",
    "```python\n",
    "def increment(value, step_size=1):\n",
    "    \"\"\"This function increments a value\"\"\"\n",
    "    print(\"Old value =\", value)\n",
    "    value += step_size\n",
    "    print(\"New value =\", value)\n",
    "\n",
    "increment(10,5)\n",
    "increment(10)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Old value = 10\n",
    "New value = 15\n",
    "Old value = 10\n",
    "New value = 11\n",
    "```\n",
    "\n",
    "Now, there are two calls to the `increment` function:\n",
    "\n",
    "```python\n",
    "increment(10,5)\n",
    "increment(10)\n",
    "```\n",
    "\n",
    "The first call to `increment` includes arguments for both parameters. The output, as expected, increments the value by 10 to 15.\n",
    "\n",
    "The second call does _not_ include the argument for the second parameter. Thus, the function uses the _default_ values that was specified in the function's definition. The output shows that the value of 10 was incremented by the default step size (1) to 11.\n",
    "\n",
    "---\n",
    "\n",
    "## Keyword Arguments\n",
    "\n",
    "Above, you saw that you must provide arguments to a function in the same sequence as expressed in the function's definition. Each of these arguments is referred to as a `positional argument`.\n",
    "\n",
    "However, arguments can also be provided as a key-value pair, which means the order is no longer relevant. To illustrate take a look at the change to the call to the `increment` function below:\n",
    "\n",
    "```python\n",
    "increment(value=2, step_size=2)\n",
    "```\n",
    "\n",
    "`value=2` and `step_size=2` are each a `keyword argument`; the key and value are both provided.\n",
    "\n",
    "If the sequence is changed, it will still work and produce the same output:\n",
    "\n",
    "```python\n",
    "increment(step_size=3, value=3)\n",
    "```\n",
    "\n",
    "As you can see, when you use _keyword arguments_, the sequence of the function's parameters is irrelevant.\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>When using <em>keyword arguments</em> be sure to use the <b>exact</b> parameter name!</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5c005658-a90f-450d-b6b9-80d1d543e46d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "59d62ef5b4ad4ad1833a9c54165d0d56",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Parameters are used when invoking a function?\\n'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "06d4a41fe84f4fc6a5dfc535f53cc000",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. When two parameters are given, only one argument…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "01e4e6fa633e48eb9fe6060c287f3326",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. Which of the following are types of arguments?\\n…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L5P3Q1, L5P3Q2, L5P3Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1aade2-59af-4cbc-b5ed-da31e39f266d",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 4 - Returning Data From a Function<a class=\"anchor\" id=\"DS109L5_page_4\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba2ed6e-98dd-43f7-8761-6ecc9a13af08",
   "metadata": {},
   "source": [
    "# Returning Data From a Function\n",
    "\n",
    "More often than not, the functions that you create in your apps will return a value or a set of values. Consider the example you saw earlier with the `increment` function; it incremented the value that was provided as an argument and printed it to the console. Below, the function has been modified to, instead, return the result of the arithmetic operation.\n",
    "\n",
    "```python\n",
    "def increment(value, step_size=1):\n",
    "    \"\"\"This function increments a value\"\"\"\n",
    "    return value + step_size\n",
    "\n",
    "new_value = increment(5, 3)\n",
    "print(\"The new value is\", new_value)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "The new value is 8\n",
    "```\n",
    "\n",
    "In the definition of the `increment` function, take a look at the one line of code (not the docstring):\n",
    "\n",
    "```python\n",
    "return value + step_size\n",
    "```\n",
    "\n",
    "To return a value from a function, you use the `return` keyword followed by the value, variable, or expression.\n",
    "\n",
    "When `increment` is called, the value returned by the function is captured in the `new_value` variable, which you can see as it's printed to the console.\n",
    "\n",
    "Here's another example:\n",
    "\n",
    "```python\n",
    "def sum(x, y):\n",
    "    \"\"\"This function sums the inputs\"\"\"\n",
    "    return x + y\n",
    "\n",
    "result = sum(10, 15)\n",
    "print(\"The sum of 10 and 15 is\", result)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "The sum of 10 and 15 is 25\n",
    "```\n",
    "\n",
    "This time, the `sum` function returns the _sum_ of `x` and `y`. The `result` variable is assigned this returned value, and it is added to the message printed to the console.\n",
    "\n",
    "Great! Now you know how to return data back from a function. However, what about if you need to return multiple values?\n",
    "\n",
    "You can return any data type from a function. You can return a number, string, list, dictionary, and tuple.\n",
    "\n",
    "Take a look at the function below that returns a tuple of dictionaries:\n",
    "\n",
    "```python\n",
    "def get_settings():\n",
    "    \"\"\"This function returns two dictionaries as a tuple\"\"\"\n",
    "    dict1 = {'name': 'Bob', 'color': 'blue'}\n",
    "    dict2 = {'name': 'Sally', 'color': 'red'}\n",
    "    return (dict1, dict2)\n",
    "\n",
    "tuple = get_settings()\n",
    "print(tuple)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "({'name': 'Bob', 'color': 'blue'}, {'name': 'Sally', 'color': 'red'})\n",
    "```\n",
    "\n",
    "As you can see, you have a lot of flexibility when it comes to the types of data you can return from your functions.\n",
    "\n",
    "---\n",
    "\n",
    "## Returning \"Nothing\" From a Function\n",
    "\n",
    "All functions actually return a value, whether you specify it or not. If there is no explicit return statement, the function returns `None`, which is another Python keyword.\n",
    "\n",
    "The `None` keyword is a special type in Python that represents _nothingness_. If a variable has a value of `None`, it ultimately means it has _no value_.\n",
    "\n",
    "Take a look at the code below. It contains the first function that you saw in this lesson &mdash; `greeting()` &mdash; which does not return anything explicitly.\n",
    "\n",
    "```python\n",
    "def greeting():\n",
    "    \"\"\"This function prints a greeting\"\"\"\n",
    "    print(\"Hello!\")\n",
    "\n",
    "print(greeting())\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Hello!\n",
    "None\n",
    "```\n",
    "\n",
    "As you can see in the output, when the \"result\" of the `greeting()` call is printed to the console, it prints the value `None`. You can see this below the first line of the output, where \"Hello!\" is printed.\n",
    "\n",
    "Great! Now that you understand how to define a function with or without parameters, invoke a function with or without parameters, and return data from a function, it's time to discuss _scope_.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead4ad3c-2fe6-457e-8924-1410e951bebd",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 5 - Local Variables and Scope<a class=\"anchor\" id=\"DS109L5_page_5\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbc06a2-e702-47a1-942f-cbcbe31221a7",
   "metadata": {},
   "source": [
    "# Local Variables and Scope\n",
    "\n",
    "When declaring variables inside of a function, they are not related to any other variable with the same name that is used outside of that function; this means the variable names are considered _local_ to that function. This is known as the _scope_ of the variable. All variables have the scope of the block that they are declared in, starting from the definition of the function.\n",
    "\n",
    "When talking about `scope`, all variables in a program may not be accessible in all locations of that program. It all depends on where the variable was declared. The scope of a variable determines where that variable can be accessed. The two basic scopes of variables in Python are `global` and `local`.\n",
    "\n",
    "What this means is that local variables can be accessed **only** inside the function in which they are declared, whereas global variables can be accessed throughout the program by **all** functions. When a function is called, the variables inside that function are brought into scope.\n",
    "\n",
    "> **TAKE AWAY:** - Variables that are defined inside a function body have a local scope, and those defined outside have a global scope.\n",
    "\n",
    "Let's take a look at a few examples:\n",
    "\n",
    "```python\n",
    "# this `user` variable is declared outside of the function\n",
    "user = 'Andrew Jones'\n",
    "\n",
    "def my_function(first, last):\n",
    "    # this `user` variable is declared inside of the function\n",
    "    # and is unrelated to the `user` variable declared outside of the function\n",
    "    user = first + ' ' + last\n",
    "    return user\n",
    "\n",
    "print(user)\n",
    "```\n",
    "\n",
    "What do you think will be printed when the print function is executed?\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```\n",
    "Andrew Jones\n",
    "```\n",
    "\n",
    "The `user` variable that was declared outside of the function is printed. Now, if you want to print the `user` variable in the function you would need to invoke the function like so:\n",
    "\n",
    "```python\n",
    "print(my_function('John', 'Smith'))\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "John Smith\n",
    "```\n",
    "\n",
    "Here you can see that the function was invoked and the `user` variable inside of the function is used to store the new name.\n",
    "\n",
    "In the following example, the _global_ variable `user` will be used inside of the function.\n",
    "\n",
    "```python\n",
    "# The user variable is in global scope\n",
    "user = \"Andrew Jones\"\n",
    "\n",
    "def the_user():\n",
    "    \"\"\"Return the value of global variable user\"\"\"\n",
    "    # The global variable user is returned\n",
    "    return user\n",
    "```\n",
    "\n",
    "Now, when the function is invoked the value of the _global_ variable `user` will be used.\n",
    "\n",
    "```python\n",
    "print(the_user())\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "Andrew Jones\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## The Global Statement\n",
    "\n",
    "As you saw earlier, variables defined outside of any function are _global_ and can be referenced from within a function. However, these values cannot be changed. If you need to change a global variable, you need to declare it inside of the function's definition using the `global` keyword.\n",
    "\n",
    "For example,\n",
    "\n",
    "```python\n",
    "y = 25\n",
    "\n",
    "def my_function():\n",
    "    global y\n",
    "\n",
    "    print('y is', y)\n",
    "    y = 5\n",
    "    print('the new value of global y is', y)\n",
    "\n",
    "my_function()\n",
    "print('y is now', y)\n",
    "```\n",
    "\n",
    "When this code snippet is executed the output is:\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "y is 25\n",
    "the new value of global y is 5\n",
    "y is now 5\n",
    "```\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "55f014f2-81ec-4695-8b0b-194f9578a471",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3ee2ed3836724e3c8a4298395e35f87b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. A variable that is declared inside of a function…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L5P5Q1)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97e85b6c-3a94-4817-8814-adb1b04943e6",
   "metadata": {},
   "source": [
    "```python\n",
    "num = 15\n",
    "\n",
    "\n",
    "\n",
    "def new_num(x):\n",
    "\n",
    "\n",
    "\n",
    "    num = 10\n",
    "\n",
    "    return num * x\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "73db735a-0cb5-48a0-947e-bf1155c2f2cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7c489261a9a4482a8298da5604edfc5c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. In the above code snippet, to change the value o…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c6877c789ed34853a6686770e8bbdcea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. It is possible to assign a value to a variable d…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try: \n",
    "    display(L5P5Q2, L5P5Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9e3b8a-9224-447f-8cf7-5035cae86421",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 6 - Functions Activity Part 1<a class=\"anchor\" id=\"DS109L5_page_6\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81e2098-28ef-4ff5-a155-afe824de4323",
   "metadata": {},
   "source": [
    "Create a function named `get_average` that:\n",
    "\n",
    "- Has three numeric parameters: `x`, `y`, and `z`.\n",
    "\n",
    "- Returns the _average_ of the three parameters. Remember, the average is the sum of all items divided by the count.\n",
    "def get_average(x, y, z):\n",
    "    return (x + y + z) / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c52726ea-137c-46ba-a9c6-b5ce43dfe820",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_average(x, y, z):\n",
    "    return (x + y + z) / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42cb7d8a-aced-42e5-ac24-32acf8c95473",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 7 - Functions Activity Part 2<a class=\"anchor\" id=\"DS109L5_page_7\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0debaf-5fae-4035-8e7d-ae62e62456cb",
   "metadata": {},
   "source": [
    "Create a function named `get_count` that:\n",
    "\n",
    "- Has two parameters:\n",
    "    - `data_list`: a list of numeric values.\n",
    "    - `update_count`: an __optional__ parameter with a default value of `False`.\n",
    "\n",
    "- If `update_count` is `True`, this function should set the global `count` variable to the count of the input list `data_list`.\n",
    "\n",
    "- Returns the number of items of the `data_list` parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "eae74e69-30c6-4485-9c4d-cd6678d6a94b",
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 0\n",
    "\n",
    "def get_count(data_list, update_count = False):\n",
    "    if update_count:\n",
    "        global count\n",
    "        count = len(data_list)\n",
    "    return len(data_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b3f800-0a14-4d13-8c32-390965c537ca",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 8 - Unnamed, Anonymous Functions<a class=\"anchor\" id=\"DS109L5_page_8\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4597e4b4-ce22-448d-843e-eab5ba74a9c4",
   "metadata": {},
   "source": [
    "# Unnamed, Anonymous Functions\n",
    "\n",
    "The functions that you've seen so far all have a name such that you can invoke them elsewhere in code. You can also create functions that do not have a name, which make them anonymous. Of course, you are probably wondering why you would them.\n",
    "\n",
    "In addition to showing you how to implement such unnamed functions, when and why you would use them is discussed below. However, before you dive into them, you will be installing a tool that helps with formatting.\n",
    "\n",
    "---\n",
    "\n",
    "## Setup\n",
    "\n",
    "In VS Code, ensure your integrated terminal is open. If not, you can press `control + ~` to open it.\n",
    "\n",
    "In the integrated terminal, enter the following command and hit enter (if _yapf_ is already installed, it will simply inform you):\n",
    "\n",
    "```\n",
    "pip3 install yapf\n",
    "```\n",
    "\n",
    "Next, open the __User Settings__ of VS Code:\n",
    "\n",
    "* Shortcut for MacOS is `cmd ,`\n",
    "* Shortcut for Windows is `ctrl ,`\n",
    "\n",
    "In the user settings, you will need to go to `Extensions` and then `Python`.  Then scroll down until you get to a section for `Formatting: Yapf Path` and add the word `yapf` to the box below, as shown: \n",
    "\n",
    "![Python extension window with the option Y A P F path selected. There is a text box beneath the heading where the text Y A P F is typed in. ](Media/yapf.png)\n",
    "\n",
    "Once you have the settings configured, `cmd + s` or `ctrl + s` to save. You can close the settings window once finished.\n",
    "\n",
    "---\n",
    "\n",
    "## Lambda Functions\n",
    "\n",
    "The `lamda` operator is used to create small, unnamed, and anonymous functions. These _lambda function_ are considered _throw-away_ functions, because they're only used when they're defined. Most of the time, lambda functions are used in combination with the built-in list functions `filter()` and `map()`. You'll learn about these shortly.\n",
    "\n",
    "When creating a lambda function, the following syntax is used:\n",
    "\n",
    "```python\n",
    "lambda parameter-list: expression\n",
    "```\n",
    "\n",
    "Take a look at the example below which creates a lambda function and assigns it to the variable `my_lambda`:\n",
    "\n",
    "```python\n",
    "# create lambda function and assign to variable `my_lambda`\n",
    "my_lambda = lambda x, y : x + y\n",
    "\n",
    "# print the results of calling the lambda function\n",
    "print(my_lambda(4, 5))\n",
    "```\n",
    "\n",
    "The result would be:\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "9\n",
    "```\n",
    "\n",
    "Here's another example:\n",
    "\n",
    "```python\n",
    "a = lambda x: x > 10\n",
    "\n",
    "print(a(20))\n",
    "```\n",
    "\n",
    "This function returns:\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "True\n",
    "```\n",
    "\n",
    "This new lambda function `a` tests whether the input `x` is greater than 10, returning `True` if so and `False` if not. After passing in the argument of `20`, the function executes `20 > 10` and then returns the value of `True` (because 20 is greater than 10).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36943bcd-7e16-4af1-97d3-c09e81ae5e99",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 9 - Operations That Can Be Performed on Collections<a class=\"anchor\" id=\"DS109L5_page_9\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdf2cdde-9447-49b5-8936-17d80f46b45e",
   "metadata": {},
   "source": [
    "# Operations That Can Be Performed on Collections\n",
    "\n",
    "## map()\n",
    "\n",
    "The `map()` function is used to perform an operation (or series of operations) on every item that is contained within a collection (like a list or tuple), returning the results of the operation as a list (sort of). This is best illustrated with an example.\n",
    "\n",
    "Consider the following code which takes, as input, a list of numbers and then squares each of them:\n",
    "\n",
    "```python\n",
    "# 1. the list of numbers\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "# 2. the lambda function to square a number\n",
    "square = lambda x: x * x\n",
    "\n",
    "# 3. use `map` to apply the squaring lambda function to\n",
    "# every item in the list of `numbers`\n",
    "map_results = map(square, numbers)\n",
    "\n",
    "# 4. `map` returns a special type of data, but it can be converted\n",
    "# to a list using the `list` function\n",
    "results = list(map_results)\n",
    "\n",
    "# 5. print the results\n",
    "print(results)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "[1, 4, 9, 16, 25]\n",
    "```\n",
    "\n",
    "The above code has numbered comments that are discussed below:\n",
    "\n",
    "1. First, a list of integers is created and assigned to the `numbers` variable.\n",
    "\n",
    "2. A lambda function for squaring a number is created and assigned to the variable `square`.\n",
    "\n",
    "3. The `map` function is called. As you can see, the `map` function takes two parameters:\n",
    "\n",
    "    - The lambda function to be applied to every item in a collection is the first parameter.\n",
    "\n",
    "    - The collection of items to which the lambda function will be applied is the second parameter.\n",
    "\n",
    "    The lambda function that was created in step 2 is the first argument, while the `numbers` list that was created in step 1 is the second argument. In the next code example, you'll see a situation where there are more than two parameters.\n",
    "\n",
    "    The results of the call to `map` is stored in the variable `map_results`.\n",
    "\n",
    "4. The value returned from the call to `map` is map object. If it were printed to the console, it would look like the following:\n",
    "\n",
    "    ```python\n",
    "    <map object at 0x1022a0320>\n",
    "    ```\n",
    "\n",
    "    However, this is not so useful, so it is converted into a list using `list()` and stored in the variable `results`. You saw this in an earlier lesson when using the `range()` function.\n",
    "\n",
    "5. This prints out the `results` variable, which contains the conversion from the `map` results to a list. As expected, this prints out a list, where each value is the square of the corresponding value in the original number list.\n",
    "\n",
    "Below is another example. This time, the lambda function is not stored in a variable; instead, it is passed directly to the call to `map`. Also, there are two lists this time, so the call to `map` includes both!\n",
    "\n",
    "```python\n",
    "# declare two lists of integers\n",
    "list_a = [1, 2, 3, 4, 5]\n",
    "list_b = [11, 12, 13, 14, 15]\n",
    "\n",
    "# call `map` with a lambda function that sums two numbers\n",
    "# the first number comes from `list_a`, the second comes from `list_b`\n",
    "map_results = map(lambda val_a, val_b: val_a + val_b, list_a, list_b)\n",
    "\n",
    "# print results (converting map result to list within print statement)\n",
    "print(list(map_results))\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "[12, 14, 16, 18, 20]\n",
    "```\n",
    "\n",
    "Above, the call to map includes the lambda function as the first argument, `list_a` as the second argument, and `list_b` as the final argument. This is different from the previous example, where `map` was only provided two arguments.\n",
    "\n",
    "```python\n",
    "map_results = map(lambda val_a, val_b: val_a + val_b, list_a, list_b)\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Filtering a Collection - filter()\n",
    "\n",
    "The `filter` function is used to weed through a list of items, returning only those that satisfy a condition. This condition takes the form of a lambda function that returns `True` if the item is to be included, or `False` if it should be excluded.\n",
    "\n",
    "The use of the `filter` function is the same as the `map` function. The first parameter is the lambda function, while the second parameter is the collection.\n",
    "\n",
    "Take a look at the example below, which _filters_ out the odd numbers of the provided list, returning only the even numbers:\n",
    "\n",
    "```python\n",
    "# 1. the list of numbers\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "# 2. the lambda function to return True only if the value is even\n",
    "is_even = lambda x: x % 2 == 0\n",
    "\n",
    "# 3. call `filter` using the `is_even` lambda function and the list `numbers`\n",
    "filter_results = filter(is_even, numbers)\n",
    "\n",
    "# 4. `filter` returns a special type of data like `map`, but it can be converted\n",
    "# to a list using the `list` function\n",
    "results = list(filter_results)\n",
    "\n",
    "# 5. print the results\n",
    "print(results)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "[2, 4]\n",
    "```\n",
    "\n",
    "Breaking down the above numbered comments:\n",
    "\n",
    "1. Like in the `map()` example, `numbers` is a list of integers. This represents the input collection that will be filtered.\n",
    "\n",
    "2. This is the lambda function that will return `True` if the parameter is even, otherwise `False`. For items to be included in the results of a call to `filter()`, it must return `True`.\n",
    "\n",
    "3. The `filter` function is called. Like the first `map()` example, you can see that it takes two arguments: the lambda function and the collection. The results of the call to `filter` is stored in the variable `filter_results`.\n",
    "\n",
    "4. The value returned from the call to `filter` is a filter object, which is converted to a list using the `list()` function like you saw above with `map()`. If it were printed to the console, it would look like the following:\n",
    "\n",
    "    ```python\n",
    "    <filter object at 0x1041e3358>\n",
    "    ```\n",
    "\n",
    "5. This prints out the `results` variable, which contains the conversion from the `filter` results to a list. As expected, this prints out a list that contains only even numbers.\n",
    "\n",
    "Congratulations! You've now learned some very important and useful features of the Python programming language. You will find functions everywhere, and in time, you'll find how powerful lambdas can be, particularly when used in conjunction with `map()` and `filter()`. There are, of course, many other applications where lambda functions can be used.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0d02d5-04fa-4220-9637-d02c3b32dce5",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 10 - Lambda Activity Part 1<a class=\"anchor\" id=\"DS109L5_page_10\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f9f376e-3cf8-40fd-a583-b3a72633f42a",
   "metadata": {},
   "source": [
    "Create a lambda function that has one parameter for a list of numbers. The lambda should compute the average of all of the numbers in the list. Assign the lambda to the variable named `fn_average`.\n",
    "\n",
    "Remember, to compute the average, you divide the sum by the count. You can use the built-in Python functions `sum` and `len` to compute the sum and get the length of a list, respectively. You've already seen the `len` function (e.g. __len(my_list)__).\n",
    "\n",
    "Using the `numbers` list of lists, call the `map` function to compute the averages. The call to the `map` function should be using the `numbers` and `fn_average` variables as arguments.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "92a32835-b9ae-4002-8bd7-f5daeac8fbb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [[1,2,3],[4,5,6]]\n",
    "\n",
    "fn_average = lambda l: sum(l) / len(l)\n",
    "\n",
    "averages = map(fn_average, numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ab057c0-2c87-4684-b3dd-70e4d05eb8ed",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 11 - Lambda Activity Part 2<a class=\"anchor\" id=\"DS109L5_page_11\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45123b44-436b-419d-a2b5-75af1b5bdb92",
   "metadata": {},
   "source": [
    "Given the two lists `list_a` and `list_b`, use the `map` function to compute the _product_ of the numbers of the lists. Store the results of the call to `map` in a variable named `products`.\n",
    "\n",
    "The _product_ is the result of multiplying numbers. For instance, if the input list were:\n",
    "```\n",
    "[1, 2, 3]\n",
    "[2, 3, 4]\n",
    "```\n",
    "\n",
    "The result would be:\n",
    "\n",
    "```\n",
    "[2, 6, 12]\n",
    "```\n",
    "\n",
    "```c-lms\n",
    "file-name: activity.py\n",
    "file-language: python\n",
    "```\n",
    "list_a = [4, 6, 8]\n",
    "list_b = [3, 3, 1]\n",
    "#\n",
    "# products =\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a575d27d-4c7b-4d52-87e0-ff542faf4ed1",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_a = [4, 6, 8]\n",
    "list_b = [3, 3, 1]\n",
    "\n",
    "products = map(lambda a, b: a * b, list_a, list_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c816354-6aa9-4e29-8768-a6223fc375a9",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 12 - Lesson 5 Practice Hands-On<a class=\"anchor\" id=\"DS109L5_page_12\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ff7ac5a-d490-4083-8b22-57bee44348c1",
   "metadata": {},
   "source": [
    "For your Lesson 5 Practice Hands-On, you will be working with your new knowledge of functions. For this project, you will be creating a new directory, so please follow the below setup instructions. This Hands-On will **not** be graded, but we encourage you to complete it. The best way to become a great programmer is to practice! Once you have submitted your project, you will be able to access the solution on the next page.\n",
    "\n",
    "---\n",
    "\n",
    "## Setup\n",
    "\n",
    "1. First, open up your command prompt/terminal\n",
    "2. Within your command prompt/terminal, run the following command:\n",
    "    ```text\n",
    "    cd desktop\n",
    "    ``` \n",
    "3. Next, run the following:\n",
    "    ```text\n",
    "    cd python_course\n",
    "    ```\n",
    "4. Run the following to create a new directory for this project:\n",
    "    ```text\n",
    "    mkdir lesson_five_handson\n",
    "    ```\n",
    "5. Open up a new window in VSCode. \n",
    "6. Click on the \"Explorer\" button on the left-hand side of the VSCode window.\n",
    "7. Click the `Open Folder` button.   \n",
    "8. Select the `lesson_five_handson` directory within the `python_course` folder on your Desktop. Click the `Open` button. \n",
    "10. Create a new file named `main.py` by one of the following three ways:\n",
    "    - To the right of __LESSON_FIVE_HANDSON__ in the EXPLORER is a button that looks like a piece of paper with a plus symbol in its top-left corner. If you hover your mouse over this button for a moment, a popup will appear indicating that this button will create a new file.\n",
    "    - Choose `File > New File` from the app's menu.\n",
    "    - Press `Control + N` in Windows or `Command + N` on a Mac (the plus means \"and at the same time\").\n",
    "\n",
    "Now you are ready to get started on your Lesson 5 Practice Hands-On!\n",
    "\n",
    "---\n",
    "\n",
    "## Requirements\n",
    "\n",
    "This hands-on is broken into three parts. Please complete each part within your `main.py` file.\n",
    "\n",
    "---\n",
    "## Part 1\n",
    "\n",
    "1. Create three functions that each accept three parameters.\n",
    "    * The first function should be named `sum_function` and should return the _sum_ of all numbers (add them all together)\n",
    "    * The second function should be named `product_function` and should return the _product_ of all numbers (multiply them all together)\n",
    "    * The third function should be named `average_function` and should return the _average_ of all numbers\n",
    "    > **HINT:** The average is the sum divided by the number of items.\n",
    "2. Print out the result of calling each function. For example:\n",
    "    ```python\n",
    "    print(sum_function(1, 2, 3))\n",
    "    ```\n",
    "\n",
    "    Should print:\n",
    "\n",
    "    ```\n",
    "    6\n",
    "    ```\n",
    "\n",
    "---\n",
    "## Part 2\n",
    "\n",
    "1. Create three `lambda` functions that do the same thing as the functions in step 1. Assign each lambda function the following variables:\n",
    "    - `add_numbers`\n",
    "    - `multiply_numbers`\n",
    "    - `average_numbers`\n",
    "2. Print and call the above functions\n",
    "\n",
    "---\n",
    "## Part 3\n",
    "\n",
    "1. Creating three separate lists named the following: `list_one`, `list_two`, `list_three`\n",
    "2. Add the following numbers in to their respective lists:\n",
    "    - numbers `4`, `6`, `88`, and `24` should go within `list_one`\n",
    "    - numbers `17`, `34`, `9`, and `5` should go within `list_two`\n",
    "    - numbers `63`, `20`, `98`, and `4` should go within `list_three`\n",
    "3. Create one lambda function named `average_maker` that takes in three numbers and finds the average.\n",
    "4. Use `map` to compute the average of each set of values at each index. This will produce a new list of the four average calculations. \n",
    "    - The variable name for this calculation should be `map_results` \n",
    "    - You will be using each of the lists within the `map` function.\n",
    "5. Print out the end result of using `map`.\n",
    "    > Hint! You will need to use `list()`\n",
    "6. The final output should be as shown below: \n",
    "    ```python\n",
    "    [28.0, 20.0, 65.0, 11.0]\n",
    "    ```\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Be sure to zip and submit your entire <code>lesson_five_handson</code> directory when finished!</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "629a5d70-11d0-48b4-9b61-8cd8b8880070",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 13 - Lesson 5 Practice Hands-On Solution<a class=\"anchor\" id=\"DS109L5_page_13\"></a>\n",
    "\n",
    "[Back to Top](#DS109L5_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69562ef2-cd53-4e78-8d57-ec2985779c96",
   "metadata": {},
   "source": [
    "# Solution\n",
    "\n",
    "Below is the solution to your Lesson 5 Practice Hands-On\n",
    "\n",
    "```python\n",
    "# Part 1\n",
    "\n",
    "def sum_function(num1, num2, num3):\n",
    "    return num1 + num2 + num3\n",
    "\n",
    "print(sum_function(1, 2, 3))\n",
    "\n",
    "def product_function(number1, number2, number3):\n",
    "    return number1 * number2 * number3\n",
    "\n",
    "print(product_function(4, 3, 9))\n",
    "\n",
    "def average_function(int1, int2, int3):\n",
    "    return (int1 + int2 + int3)/3\n",
    "\n",
    "print(average_function(4, 9, 7))\n",
    "\n",
    "# Part 2\n",
    "\n",
    "add_numbers = lambda numb1, numb2, numb3 : numb1 + numb2 + numb3\n",
    "\n",
    "print(add_numbers(22, 12, 10))\n",
    "\n",
    "multiply_numbers = lambda numbr1, numbr2, numbr3 : numbr1 * numbr2 * numbr3\n",
    "\n",
    "print(multiply_numbers(2, 7, 19))\n",
    "\n",
    "average_numbers = lambda integer1, integer2, integer3 : (integer1 + integer2 + integer3)/3\n",
    "\n",
    "print(average_numbers(2, 3, 8))\n",
    "\n",
    "# Part 3\n",
    "\n",
    "list_one = [4, 6, 88, 24]\n",
    "list_two = [17, 34, 9, 5]\n",
    "list_three = [63, 20, 98, 4]\n",
    "\n",
    "average_maker = lambda num1, num2, num3: (num1 + num2 + num3)/3\n",
    "\n",
    "map_results = map(average_maker, list_one, list_two, list_three)\n",
    "\n",
    "print(list(map_results))\n",
    "```"
   ]
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}