tu014-Numpy-CreatingPythongFunctions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a38d572b",
   "metadata": {},
   "source": [
    "## Reuse useful code by creating functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fcf2bcd",
   "metadata": {},
   "source": [
    "<table><tr>\n",
    "<td> <img src=\"./assets/jpnb16/denarius.jpg\" alt=\"An Ancient Roman coin (27 B.C.).\" style=\"width: 200px;\"/> </td>\n",
    "<td> <img src=\"./assets/jpnb16/breadmaker.jpg\" alt=\"A bread maker (A.D. 2022).\" style=\"width: 180px;\"/> </td>\n",
    "</tr></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "276f1c4b",
   "metadata": {},
   "source": [
    "### Learning goals\n",
    "  - Understand what is a function in programming\n",
    "  - Understand the syntax used by Python to define a function\n",
    "  - Practice with writing a function\n",
    "      - Write an example function to make data\n",
    "      - Write an example function to make a plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31049f88",
   "metadata": {},
   "source": [
    "### Recycling code\n",
    "\n",
    "Imagine if you were to be taking a data science class and you were often asked to create:\n",
    "\n",
    "  - Datasets of different means and standard deviations, say using code like: \n",
    "     `data = mu + sd*np.random.randn(siz,1)` \n",
    "  - Plots (like histograms) of the datasets. For example using `sns.kdeplot`.\n",
    "  \n",
    "You might be tempted to memorize, or even write down on a notepad, the specific code that seems to be used most often.  Looking up the code snippet from a piece of paper it would be probably fine at least in a few cases. \n",
    "\n",
    "Imagine now becoming a data scientist. Imagine handling dozens of code and analysis requests from multiple managers and clients. Many requests will likely require reusing very similar blocks of code. In theory, also in this case you *might be tempted* to use the same methid and copy and paste the same code from the piece of paper to apply to edit it and then apply it to each new request. \n",
    "\n",
    "There are better options for you. Given that your work day will likely end only after all requests have been attended to, copying and pasting might be \"suboptimal,\" to say the least."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a2728a3",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "Functions are code methods that allow to encapsulate useful code in a reusable form. Methods exist to speed up your data science work, reduce mustakes and, eliminate extra typing needed when reusing code. These methods are called [**functions**](https://en.wikipedia.org/wiki/Subroutine).\n",
    "\n",
    "[Functions, a.k.a. subroutines](https://en.wikipedia.org/wiki/Subroutine) are sequences of code packaged as units. The units can be called at different locations in code to quickly and efficiently perform the oprations implemented in the packaged code. Functions are used to address situations just like the ones described above, where a section of code is used over and over again. Functions accept inputs and return outputs. Functions, contain useful code that performs operations that are likely to be used multiple times. \n",
    "\n",
    "Functions can help make code shorter, more nimble, and easier to read. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0fdda51",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6402a675",
   "metadata": {},
   "source": [
    "### Flipping a coing to choose lunch\n",
    "\n",
    "A coin flip operation is a good, easy, example to describe how functions work in python.\n",
    "\n",
    "Imagine wanting to make a function that works just like the flip of a coin. For fun, imagine wanting to use the function to pick your lunch *Tacos!* or *Pizza!* being your options. Let's look at our first example of a function.\n",
    "\n",
    "The code below is an example of how we can do something like that, simulate coinflips. To implement the code a function was defined using Python's syntax. In Python, functions are defined with a function name and the special word `def` in front of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8caae49",
   "metadata": {},
   "outputs": [],
   "source": [
    "def coinflip() :\n",
    "    import numpy as np\n",
    "    flip = np.random.randint(2) # return a random 0 or 1\n",
    "    if flip == 0 :\n",
    "        result = 'Pizza!'\n",
    "    else :\n",
    "        result = 'Tacos!'\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "315ae776",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's test this function. \n",
    "# Run this cell multiple times\n",
    "coinflip()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98c37626",
   "metadata": {},
   "source": [
    "You should be returned either Pizza or Tacos at every coinflip call!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc51ab92",
   "metadata": {},
   "source": [
    "### Anatomy of a function\n",
    "\n",
    "Let's analyze the function above. \n",
    "\n",
    "  - def: The function begins with the word def.\n",
    "  \n",
    "  `def`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85f7a743",
   "metadata": {},
   "source": [
    "  \n",
    "  - The function name: def is followed by the function's name. The name is chosen by the programmer to reflect what the function does.\n",
    "  \n",
    "  `def coinflip`\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fa5f24f",
   "metadata": {},
   "source": [
    "  - The parenthesis: The function name is followed by a pair of parenthesis `()`. \n",
    "  \n",
    "  `def coinflip()`\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b3e6d20",
   "metadata": {},
   "source": [
    "  - The column sign (`:`): The parenthesis are followed by a column sign. \n",
    "  \n",
    "  `def coinflip() :`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c77287a1",
   "metadata": {},
   "source": [
    "  - The code lines: Indented within the function definition are the \"actual code\" lines that make up the function. When a function runs, the computer runs these lines of code from top to bottom. Below the specific lines from the function at stake.\n",
    "\n",
    "  `import numpy as np\n",
    "   flip = np.random.randint(2) # return a random 0 or 1\n",
    "   if flip == 0 :\n",
    "      result = 'Tails!'\n",
    "   else :\n",
    "      result = 'Heads!'\n",
    "   return result`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dd818c7",
   "metadata": {},
   "source": [
    "Importantly, all the code that belongs inside the function must be indented so as to align with the first letter of the function name. In other words, the following is incorrect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adfcad24",
   "metadata": {},
   "outputs": [],
   "source": [
    "def coinflip() :\n",
    "    import numpy as np\n",
    "    flip = np.random.randint(2) # return a random 0 or 1\n",
    "    if flip == 0 :\n",
    "        result = 'Tails!'\n",
    "    else :\n",
    "        result = 'Heads!'\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "791d0010",
   "metadata": {},
   "source": [
    "Just like for loops, *indentation is critical in Python*!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e386e315",
   "metadata": {},
   "source": [
    "Two additional bits of code are important to dissect from the code above.\n",
    "The second line of code `import numpy as np` in the block shows that imports must be done inside the function definition. This is because the function does not share the whole software environment and variables outside. So variables and operations inside a function will need their own definitions and imports. \n",
    "\n",
    "In the case of our coinflip we import `numpy`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7952d2ad",
   "metadata": {},
   "source": [
    "`def coinflip() :\n",
    "import numpy as np`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a1dba7b",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "  - Let's test how the code inside the function communicates to the python environment outside of the function. To do so, use the cell below to define a numpy array `d` containing the the list of numbers `[2, 3, 4, 5, 6]`. Note that we are asking to do so without importing numpy again, but assuming that the `import` operation written inside the function above is all you need also to import outside the function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5474599f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b475877a",
   "metadata": {},
   "source": [
    "  - Where you able to define the numpy array? Why not? Use this cell to explain what is happening here, why are you suddenly not able to define a numpy array? What should you do before being able to define one?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07c09de1",
   "metadata": {},
   "source": [
    "The variables and data generated by the function will need to be returned out to the outside environment and for that the special term `return` is used."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6e65620",
   "metadata": {},
   "source": [
    "`flip = np.random.randint(2) # return a random 0 or 1\n",
    "if flip == 0 :\n",
    "    result = 'Tails!'\n",
    "else :\n",
    "    result = 'Heads!'\n",
    "return result`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4565ada5",
   "metadata": {},
   "source": [
    "if that term is omitted nothing the values computed insdiethe function are not returned outside of the function. (Well, unfortunatelly it is more complicated than that but we will talk about the full story in a different tutorial.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b0147f4",
   "metadata": {},
   "source": [
    "But let's test it. if we run a modified version of `coinflip` without the return line what happens?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e10138e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def coinflip() :\n",
    "    import numpy as np\n",
    "    flip = np.random.randint(2) # return a random 0 or 1\n",
    "    if flip == 0 :\n",
    "        result = 'Pizza!'\n",
    "    else :\n",
    "        result = 'Tacos!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef1dfcc8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "47a8137d",
   "metadata": {},
   "source": [
    "What is the result? (Hint: There should be no return, no free lunch. Try.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1bea083",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8f1c4af",
   "metadata": {},
   "source": [
    "  -  Advanced question: Can you think a way to bypass (avoid) returing `result` but still showing the option selected for lunch (*Tacos* or *Pizza*)?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "407c20df",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e5e327a1",
   "metadata": {},
   "source": [
    "### A more advanced version of a function: A bread maker\n",
    "\n",
    "So far we have been discussing a very simple case for a function. One that returns a single value to the outside world. The coin flip is a simple and limited case. \n",
    "\n",
    "Often times functions need stuff to work. Just like a breadmaker: add flour, yeast, water, and salt to get some bread out! A function can act like bread maker, get raw inputs and return much needed outputs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "754d1fae",
   "metadata": {},
   "source": [
    "Let's go back to look at one of code operations we have encountered multiple times in previous tutorials. \n",
    "\n",
    "`data = mu + sd*np.random.randn(siz,1)`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc9eb656",
   "metadata": {},
   "source": [
    "Several times, we have generated data by using a random generator. Often times we have used a generator that returns normally distributed data. \n",
    "\n",
    "Imagine wanting to use what you just learned about functions to write a new function that can generate distributions of normally distributed data for you with a certain mean, standard deviation and size.\n",
    "\n",
    "To do so, we would need a function that can return `data`. We could do that by reusing what just learned with `coinflip()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e95b7edf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_normal_data():\n",
    "    import numpy as np\n",
    "    data = 5 + 2*np.random.randn(10,1)\n",
    "    return data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1454372f",
   "metadata": {},
   "source": [
    "We can take a look at the returned variable `data`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7b95450",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = my_normal_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f65a108c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# What is the mean value?\n",
    "np.mean(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59098c7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# What about the standard deviation?\n",
    "np.std(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f9d7cc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# How many data points did we get?\n",
    "np.size(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "634ca2c5",
   "metadata": {},
   "source": [
    "If the function above is run multiple times, the results will aways return:\n",
    "  - different numbers, \n",
    "  - a mean around `5`, \n",
    "  - a standard deviation around `2` and \n",
    "  - a numerosity (the size) of the sample of `10`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7be1fb2f",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "  - Use the cell below to write a function called `mybrain` that returns a variable called `butterflies` that contains 15 numbers with mean -5 and standard deviation of 0.5.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a1d63f4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "aa850c45",
   "metadata": {},
   "source": [
    "#### Functions can return data by variable assigment\n",
    "\n",
    "Note that we have already encountered a difference from `coinflip()`. \n",
    "\n",
    "The function `my_normal_data()` was called and the value returned by the function was assigned to a variable called `d`. \n",
    "\n",
    "In the early example, `coinflip()` did not return usable data. All we wanted from the function was to visualize the value of a varible internal to the function. \n",
    "\n",
    "In the case right above here, we wanted to actual data to compute the `mean`, the `std` and measure the `size`. To do so, we had to use additional functionality of python; we assigned the returning variable `data`, that existed internal to the function to the variable `d` which existed outside of the function.\n",
    "\n",
    "It is `d` that we can use as data and it is `d` that we can study. So a new piece of learning here:\n",
    " - Python functions can return internal variables but the variables must be assigned to output variables to be used outside of the function."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2ec9c9d",
   "metadata": {},
   "source": [
    "#### The bread maker\n",
    "\n",
    "This is all great. \n",
    "\n",
    "We have now learned how to create an advanced function that returns data. Yet, this is not quite a breadmaker yet! \n",
    "\n",
    "Wouldn't it be terrific if the function could receive as inputs the size, the mean and the standard deviation of the data sample? That would allow a user to specify the center and spread of the distribution of data as well as the size of the data set. \n",
    "\n",
    "That would look pretty much like a bread maker: We add ingredients and return freshly baked awesome bread."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a0f1cfa",
   "metadata": {},
   "source": [
    "#### Functions can accept variables as inputs and use those variables to perform operations\n",
    "\n",
    "Python function can take inputs just like they can return outputs. *Input variables* can be added at the function definition and the function can then use the values stored inside the variables for internal computations. \n",
    "\n",
    "Below an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0650650e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_awesome_data(mu,sd,siz):\n",
    "    import numpy as np\n",
    "    data = mu + sd*np.random.randn(siz,1);\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0434428a",
   "metadata": {},
   "outputs": [],
   "source": [
    " # we ask for 10 numbers with mean 5 and standard deviation of 2\n",
    "# (standard deviation sets the random variability in the numbers)\n",
    "d = my_awesome_data(5,2, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79df9374",
   "metadata": {},
   "outputs": [],
   "source": [
    "# What is the mean value?\n",
    "np.mean(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e546d8c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# What about the standard deviation?\n",
    "np.std(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e05c31f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# How many data points did we get?\n",
    "np.size(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "979de8d5",
   "metadata": {},
   "source": [
    "What happens if you change the inout values say from `(0,2,20)` to `(10,4,200)`? Give it a try:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "237766b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = my_awesome_data(10,4,200)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c03efe35",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "  - What happens if you omit the inputs? Use the cell below to first try to run the function omitting the output and then use the following cell to explain what is going on using your own words (Hint: What does the error say?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "661e2e88",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "48446339",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f0a6ccb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# add example of non positional inout assignment\n",
    "d = my_awesome_data(sd=4,siz=200,mu=10)\n",
    "np.mean(d)\n",
    "\n",
    "# add example of default values asigment to the function\n",
    "def my_awesome_data(mu=10,sd=2,siz=100):\n",
    "    import numpy as np\n",
    "    data = mu + sd*np.random.randn(siz,1);\n",
    "    return data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42744d59",
   "metadata": {},
   "source": [
    "This is an awesome new function that doesn't just return data, but it can return the data you need. You can pick the flower (the mean), the salt (the standard deviation) and the yeast (the size of the dataset) and the function will make bread for you, or better than that, the function will give you the data you want.\n",
    "\n",
    "The function can be reused, copied, pasted and once defined in a jupyter notebook it can be used *ad infinitum* (again and again)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "462615ad",
   "metadata": {},
   "source": [
    "### Combining functions to simplify and reuse plotting code\n",
    "\n",
    "In a past tutorial, we have learned how to use `matplotlib.pyplot` to make pretty plots. The code of one of the past examples is reproduced below. It makes four pretty plots of a Linear, a Quandratic, a Cubic and a Quartic function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f31045e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# make sure we have our tools\n",
    "import numpy as np                 \n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "# compute our polynomials\n",
    "my_x = np.array([-4, -3, -2, -1, 0, 1, 2, 3, 4])\n",
    "y_lin = my_x\n",
    "y_quad = my_x**2  # ** is Python for exponentiation\n",
    "y_cube = my_x**3\n",
    "y_quart = my_x**4 \n",
    "\n",
    "# set our style\n",
    "plt.style.use('ggplot')\n",
    "axisLabelSize = 16\n",
    "titleSize = 20\n",
    "\n",
    "# make a big square figure\n",
    "plt.figure(figsize=(7, 7))\n",
    "\n",
    "# Now make each of the plots!\n",
    "\n",
    "# first is top left\n",
    "plt.subplot(221)                               \n",
    "plt.plot(my_x, y_lin, label = 'linear');  \n",
    "plt.xlabel('x', fontsize = axisLabelSize);           \n",
    "plt.ylabel('x', fontsize = axisLabelSize);\n",
    "plt.title('Linear', fontsize = titleSize);\n",
    "plt.text(-2, 2, 'axes panel 1')\n",
    "\n",
    "# then top right\n",
    "plt.subplot(222)                              \n",
    "plt.plot(my_x, y_quad, label = 'quadratic');\n",
    "plt.xlabel('x', fontsize = axisLabelSize);\n",
    "plt.ylabel('x squared', fontsize = axisLabelSize);\n",
    "plt.title('Quadradic', fontsize = titleSize,);\n",
    "plt.text(-1, 10, 'axes panel 2')\n",
    "\n",
    "# third is bottom left\n",
    "plt.subplot(223)\n",
    "plt.plot(my_x, y_cube, label = 'cubic');\n",
    "plt.xlabel('x', fontsize = axisLabelSize);\n",
    "plt.ylabel('x cubed', fontsize = axisLabelSize);\n",
    "plt.title('Cubic', fontsize = titleSize,);\n",
    "plt.text(-2, 40, 'axes panel 3')\n",
    "\n",
    "# then bottom right\n",
    "plt.subplot(224)\n",
    "plt.plot(my_x, y_quart, label = 'quartic');\n",
    "plt.xlabel('x', fontsize = axisLabelSize);\n",
    "plt.ylabel('x to the fourth', fontsize = axisLabelSize);\n",
    "plt.title('Quartic', fontsize = titleSize,);\n",
    "plt.text(-1, 150, 'axes panel 4')\n",
    "\n",
    "# finally, make everything automagically fit\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68f7a511",
   "metadata": {},
   "source": [
    "We have to admit that the plotting code is long and ugly.\n",
    "\n",
    "We are going to use a function to separate the plotting code from the data generation code so to be able to call this whole block of code multiple times. \n",
    "\n",
    "First of all we have the data generation block of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9aa2f7f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is the data generation code\n",
    "import numpy as np                 \n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "# compute our polynomials\n",
    "my_x = np.array([-4, -3, -2, -1, 0, 1, 2, 3, 4])\n",
    "y_lin = my_x\n",
    "y_quad = my_x**2  # ** is Python for exponentiation\n",
    "y_cube = my_x**3\n",
    "y_quart = my_x**4 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2128758",
   "metadata": {},
   "source": [
    "After that, we have the plotting code. We are not going to stick that code into a function.\n",
    "\n",
    "The function will need as inputs the data we generated outside:\n",
    "  - my_x\n",
    "  - y_lin\n",
    "  - y_quad\n",
    "  - y_cube\n",
    "  - y_quart\n",
    "  \n",
    " The rest of the code will be just like above. The new function will take as inputs the data (5 vectors of the same size) and make plots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e47e1a06",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_spiffy_plotting_func(my_x, y_lin, y_quad, y_cube, y_quart):\n",
    "    import numpy as np                 \n",
    "    import matplotlib.pyplot as plt # This is the function that will plot the data\n",
    "    \n",
    "    # set our style\n",
    "    plt.style.use('ggplot')\n",
    "    axisLabelSize = 16\n",
    "    titleSize = 20\n",
    "\n",
    "    # make a big square figure\n",
    "    plt.figure(figsize=(7, 7))\n",
    "\n",
    "    # Now make each of the plots!\n",
    "\n",
    "    # first is top left\n",
    "    plt.subplot(221)                               \n",
    "    plt.plot(my_x, y_lin, label = 'linear');  \n",
    "    plt.xlabel('x', fontsize = axisLabelSize);           \n",
    "    plt.ylabel('x', fontsize = axisLabelSize);\n",
    "    plt.title('Linear', fontsize = titleSize);\n",
    "    plt.text(-2, 2, 'axes panel 1')\n",
    "\n",
    "    # then top right\n",
    "    plt.subplot(222)                              \n",
    "    plt.plot(my_x, y_quad, label = 'quadratic');\n",
    "    plt.xlabel('x', fontsize = axisLabelSize);\n",
    "    plt.ylabel('x squared', fontsize = axisLabelSize);\n",
    "    plt.title('Quadradic', fontsize = titleSize,);\n",
    "    plt.text(-1, 10, 'axes panel 2')\n",
    "\n",
    "    # third is bottom left\n",
    "    plt.subplot(223)\n",
    "    plt.plot(my_x, y_cube, label = 'cubic');\n",
    "    plt.xlabel('x', fontsize = axisLabelSize);\n",
    "    plt.ylabel('x cubed', fontsize = axisLabelSize);\n",
    "    plt.title('Cubic', fontsize = titleSize,);\n",
    "    plt.text(-2, 40, 'axes panel 3')\n",
    "\n",
    "    # then bottom right\n",
    "    plt.subplot(224)\n",
    "    plt.plot(my_x, y_quart, label = 'quartic');\n",
    "    plt.xlabel('x', fontsize = axisLabelSize);\n",
    "    plt.ylabel('x to the fourth', fontsize = axisLabelSize);\n",
    "    plt.title('Quartic', fontsize = titleSize,);\n",
    "    plt.text(-1, 150, 'axes panel 4')\n",
    "\n",
    "    # finally, make everything automagically fit\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a76af44e",
   "metadata": {},
   "source": [
    "Let's next launch the the function passing the data!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5c19429",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_spiffy_plotting_func(my_x, y_lin, y_quad, y_cube, y_quart)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "304e52d2",
   "metadata": {},
   "source": [
    "Isn't that nice? We have a one line of code now that can make that pretty plot of ours.\n",
    "\n",
    "What if we wanted to change the font size later one? We could add additional parameters to allow us to variate the font size everytime we call the function. Let's do that. We will redefine the function adding the font size as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a12ecda0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_spiffy_plotting_func(my_x, y_lin, y_quad, y_cube, y_quart, axisLabelSize=20, titleSize=16,):\n",
    "# This is the function that will plot the data\n",
    "    # set our style\n",
    "    plt.style.use('ggplot')\n",
    "\n",
    "    # make a big square figure\n",
    "    plt.figure(figsize=(7, 7))\n",
    "\n",
    "    # Now make each of the plots!\n",
    "\n",
    "    # first is top left\n",
    "    plt.subplot(221)                               \n",
    "    plt.plot(my_x, y_lin, label = 'linear');  \n",
    "    plt.xlabel('x', fontsize = axisLabelSize);           \n",
    "    plt.ylabel('x', fontsize = axisLabelSize);\n",
    "    plt.title('Linear', fontsize = titleSize);\n",
    "    plt.text(-2, 2, 'axes panel 1')\n",
    "\n",
    "    # then top right\n",
    "    plt.subplot(222)                              \n",
    "    plt.plot(my_x, y_quad, label = 'quadratic');\n",
    "    plt.xlabel('x', fontsize = axisLabelSize);\n",
    "    plt.ylabel('x squared', fontsize = axisLabelSize);\n",
    "    plt.title('Quadradic', fontsize = titleSize,);\n",
    "    plt.text(-1, 10, 'axes panel 2')\n",
    "\n",
    "    # third is bottom left\n",
    "    plt.subplot(223)\n",
    "    plt.plot(my_x, y_cube, label = 'cubic');\n",
    "    plt.xlabel('x', fontsize = axisLabelSize);\n",
    "    plt.ylabel('x cubed', fontsize = axisLabelSize);\n",
    "    plt.title('Cubic', fontsize = titleSize,);\n",
    "    plt.text(-2, 40, 'axes panel 3')\n",
    "\n",
    "    # then bottom right\n",
    "    plt.subplot(224)\n",
    "    plt.plot(my_x, y_quart, label = 'quartic');\n",
    "    plt.xlabel('x', fontsize = axisLabelSize);\n",
    "    plt.ylabel('x to the fourth', fontsize = axisLabelSize);\n",
    "    plt.title('Quartic', fontsize = titleSize,);\n",
    "    plt.text(-1, 150, 'axes panel 4')\n",
    "\n",
    "    # finally, make everything automagically fit\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fad21a4e",
   "metadata": {},
   "source": [
    "We can now run this function. We will pass slightly different font size (14 and 12, instead of 16 and 20)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8a71eb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_spiffy_plotting_func(my_x, y_lin, y_quad, y_cube, y_quart, 14, 12)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06a31393",
   "metadata": {},
   "source": [
    "Sweet.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f5f7c9a",
   "metadata": {},
   "source": [
    "In this tutorial we have learned the basic syntax of functions in python. \n",
    "\n",
    "The definition, the inputs, the ouputs. We have also practiced with defining two types of functions, one that can be used to generate data. The other, that can be used to plot data.\n",
    "\n",
    "There many applications to functions and indeed the majority of what we have been using so far in Python is defined as a function! There are also other apsects of functions and how they work that we have not covered above.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18042d95",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    " - If we wanted to be able to change the style of the plots above, say we would like to pick 'fivethirtyeight' or other styles, how would you modify the definition of `my_spiffy_plotting_func()` so to allow changing the style, every time the function is called? Use the cell below to answer the question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37b136e7",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}