Activity_ Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XhsOK4sU-hwF"
   },
   "source": [
    "<h1>Activity: Functions</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p44i56Cl-hwG"
   },
   "source": [
    "## Introduction \n",
    "\n",
    "In this lab, you will practice defining functions and returning values, writing clean code, and using comments to scaffold code.\n",
    "\n",
    "As a data professional, you'll often need to reuse the same block of code more than once when you're writing Python code to automate a certain task. This is why functions are important. You can call functions whenever you need the computer to execute those steps. Python has built-in functions that have already been defined and also provides tools for users to define their own functions.\n",
    "\n",
    "In this lab, you'll define and call a function that calculates the revenue a theater makes depending on the number of tickets sold, then test the function with a new value.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W3FWqR7i-hwH"
   },
   "source": [
    "## Tips for completing this lab\n",
    "\n",
    "As you navigate this lab, keep the following tips in mind:\n",
    "\n",
    "- `### YOUR CODE HERE ###` indicates where you should write code. Be sure to replace this with your own code before running the code cell.\n",
    "- Feel free to open the hints for additional guidance as you work on each task.\n",
    "- To enter your answer to a question, double-click the markdown cell to edit. Be sure to replace the \"[Double-click to enter your responses here.]\" with your own answer.\n",
    "- You can save your work manually by clicking File and then Save in the menu bar at the top of the notebook.\n",
    "- You can download your work locally by clicking File and then Download and then specifying your preferred file format in the menu bar at the top of the notebook.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xbX_PD6J-hwH"
   },
   "source": [
    "## Task 1: Analyze a function\n",
    "\n",
    "In your work as a data analyst for a movie theater, you're asked to quickly calculate how much the theater has made in sales so far.\n",
    "\n",
    "In the following cell, analyze the function named `total_sales` and make note of your observations.\n",
    "\n",
    "You do not need to run this cell, but if you do it will not produce an output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "ucfgn-v4-hwH"
   },
   "outputs": [],
   "source": [
    "# Define a function named `total_sales`\n",
    "def total_sales():\n",
    "\n",
    "    # Return a value\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IHDaBz2d-hwI"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 1</strong></h4></summary>\n",
    "\n",
    "You can refer back to what you've learned about functions.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4t5JftFD-hwI"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 2</strong></h4></summary>\n",
    "\n",
    "When analyzing the function definition, make sure to observe the function body, which is the indented block of code after the function header.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8z6Mqjm--hwI"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 3</strong></h4></summary>\n",
    "\n",
    "Notice that the code comments on each line clearly explain how the function operates.\n",
    "\n",
    "Code comments can also be used to scaffold code as you build it, since Python will not interact with the text captured as a comment.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jWGW2DeM-hwJ"
   },
   "source": [
    "## Task 2: Add a parameter and calculations to the function\n",
    "\n",
    "As you continue refining your code, imagine that the price of tickets is $7.99. Now you will need to add a parameter to the function definition and the calculation to the function body.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MNsz5GOI-hwJ"
   },
   "source": [
    "### 2a: Add a calculation to the function\n",
    "\n",
    "In this task, update the `total_sales` function so it returns the value of the number of tickets `n` multiplied by the price `7.99`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "XisiWnjN-hwJ"
   },
   "outputs": [],
   "source": [
    "# Define a function named `total_sales`\n",
    "def total_sales(n):\n",
    "\n",
    "    # Return a value\n",
    "    return n * 7.99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mLho0ga--hwJ"
   },
   "source": [
    "### 2b: Call the function\n",
    "\n",
    "With the calculations added to the `total_sales` function, test it with a value of `59`.\n",
    "\n",
    "*Example:*\n",
    "\n",
    "```\n",
    "[IN]  total_sales(59)\n",
    "[OUT] 471.41\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "noiw4TZ2-hwJ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "471.41"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_sales(59)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fYOI2RHH-hwL"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 1</strong></h4></summary>\n",
    "\n",
    "You can refer back to what you learned about functions and arithmetic operators.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4c0MTgRM-hwL"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 2</strong></h4></summary>\n",
    "\n",
    "To create a function, use the `def` keyword to define the function, then write the name of the function, followed by parentheses and a colon: `():`. This set of parentheses is where a parameter would be added.\n",
    "\n",
    "The body of the function begins on the next line and is indented, conventionally by four spaces. This is where to write the function's operations (such as arithmetic calculations) and a `return` statement.\n",
    "\n",
    "To call a function, type the function name followed by parentheses, with a parameter in the parentheses.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TlZ2OFnA-hwL"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 3</strong></h4></summary>\n",
    "\n",
    "After defining the `total_sales` function, add a parameter `n` to the function.\n",
    "\n",
    "In the body of the function, multiply the parameter by the ticket price to get total sales.\n",
    "\n",
    "To call the function, replace `n` with the number of tickets in the function's parenthesis, then run the cell.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8TQyh5aT-hwL"
   },
   "source": [
    "# Task 3: Create a function that accepts two values\n",
    "\n",
    "You learn that the price of tickets is more expensive for opening night, and now you need to create a function that will accept two values and return their total value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X4E5T6X9-hwL"
   },
   "source": [
    "### 3a: Refine the `total_sales` function\n",
    "\n",
    "*  Update your `total_sales` function so it accepts two parameters:\n",
    "    * `price` for the price per ticket\n",
    "    * `num_tickets` for the total number of tickets.\n",
    "\n",
    "* Return the product of the two arguments. Use the Python `round()` function to round the returned value to two decimal places. Refer to the [round() Python documentation](https://docs.python.org/3/library/functions.html#round) for more information regarding this function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "W1syLfyl-hwM"
   },
   "outputs": [],
   "source": [
    "# Define a function named `total_sales`\n",
    "def total_sales(price, num_tickets):\n",
    "\n",
    "    # Return a value\n",
    "    return round(price * num_tickets, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6D0whKnN-hwM"
   },
   "source": [
    "### 3b: Call the function\n",
    "\n",
    "Then, call the function with the value of `15.99` for `price` and `1001` for the number of tickets sold (`num_tickets`).\n",
    "\n",
    "Example:\n",
    "\n",
    "```\n",
    "[IN]  total_sales(15.99, 1001)\n",
    "[OUT] 16005.99\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "0QEF1aJw-hwM"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16005.99"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_sales(15.99, 1001)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xd93S8Q3-hwN"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 1</strong></h4></summary>\n",
    "\n",
    "Refer to what you learned about functions, arithmetic operators, and the `round()` function.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YDzG6_gh-hwN"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 2</strong></h4></summary>\n",
    "\n",
    "Defining up a function that accepts two parameters is a very similar process to defining a function with just one.\n",
    "\n",
    "Begin by defining the function and naming it, but instead of a single parameter within the parentheses, place two parameters separated by a comma (`,`).\n",
    "\n",
    "The body of the function is still on a new line and indented four spaces. The `round()` function is included here, and the calculation of the two parameters takes place within the `round()` function's parentheses.\n",
    "\n",
    "When calling the new function, type the name of the function followed by a set of parentheses. Then, place the parameters that the function is operating on within the parentheses, separated by a comma.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YYLt_9Xm-hwN"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 3</strong></h4></summary>\n",
    "\n",
    "Define a function called `total_sales` that calculates the total dollar value of the tickets sold based on the per-ticket price (`price`), and the number of tickets sold (`num_tickets`).\n",
    "\n",
    "In the body of the function, multiply the parameters to get the total and round the calculation to two decimal places.\n",
    "\n",
    "To call the function, write the name of the function on a new line and replace the parameters with the price per ticket and number of tickets sold.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QbNTK2lJ-hwN"
   },
   "source": [
    "# Task 4: Test the function with different values\n",
    "\n",
    "As prices and sales fluctate, your function will need to accept different values and still return the total sales.\n",
    "\n",
    "In this task, practice calling your function with different values.\n",
    "\n",
    "Example:\n",
    "\n",
    "```\n",
    "[IN]  total_sales(16.99, 1232)\n",
    "[OUT] 20931.68\n",
    "\n",
    "[IN]  total_sales(10.50, 1472)\n",
    "[OUT] 15456.0\n",
    "\n",
    "[IN]  total_sales(5.00, 349)\n",
    "[OUT] 1745.0\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "5-FAYyBe-hwN"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20931.68"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Call `total_sales` with 16.99 price and 1232 num_tickets\n",
    "total_sales(16.99, 1232)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "DHD5DkK6-hwO"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15456.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Call `total_sales` with 10.50 price and 1472 num_tickets\n",
    "total_sales(10.50, 1472)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "dkWOKCuR-hwO"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1745.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Call `total_sales` with 5.00 price and 349 num_tickets\n",
    "total_sales(5.00, 349)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p_NubEBx-hwO"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 1</strong></h4></summary>\n",
    "\n",
    "You can refer to what you've learned about calling functions with multiple parameters.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "B61eLOgk-hwO"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 2</strong></h4></summary>\n",
    "\n",
    "Call the function by writing the name, followed by parenthesis. Write the two values you want to calculate inside the parenthesis, separated by a comma.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fSDK4WCH-hwP"
   },
   "source": [
    "<details>\n",
    "  <summary><h4><strong>Hint 3</strong></h4></summary>\n",
    "\n",
    "To run the function and calculate a new total, call `total_sales()` and write `16.99, 1232` inside the parenthesis.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U1MOXazU-hwP"
   },
   "source": [
    "# Conclusion\n",
    "\n",
    "**What are your key takeaways from this lab?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ep-uvqwi-hwP"
   },
   "source": [
    "I had a refresher on the basics of writing functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Congratulations!** You've completed this lab. However, you may not notice a green check mark next to this item on Coursera's platform. Please continue your progress regardless of the check mark. Just click on the \"save\" icon at the top of this notebook to ensure your work has been logged."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "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": 1
}