2_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Encapsulating Code with Functions\n",
    "\n",
    "- prepared by [Katarina Nastou](https://www.cpr.ku.dk/staff/?pure=en/persons/672471)\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pythontsunami/teaching/blob/intro/2_functions.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Objectives\n",
    "\n",
    "* Describe what a function is and how they are useful\n",
    "* Explain exactly what the return keyword does and some of the side effects when using it\n",
    "* Add parameters to functions to output different data\n",
    "* Understand how scope works in a function\n",
    "* Add keyword arguments to functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What is a function?\n",
    "\n",
    "Just as we've learned that Python does a lot of work \"under the hood\"--translating its \"syntactic sugar\" into many lines of Python, interpreting that code into the C language, then compiling it into machine language, and so on--we too can wrap our code into simple functions, thereby making those lines easier to understand, debug, and reuse.  The basic unit of encapsulation in programming is called a [**function**](https://docs.python.org/3/glossary.html#term-function), and they can mostly be thought of as a pipeline:\n",
    "\n",
    "**Input(s) -> [Some Code] -> Output(s)**\n",
    "\n",
    "In Python, a function is any object that is **callable** (i.e. can use the parentheses after the name).  When **calling** functions, Python's syntax is like so:\n",
    "\n",
    "```python\n",
    "output = function(input1, input2)\n",
    "```\n",
    "\n",
    "Creating a function is done using the same code block style we've seen in for-loops and if-loops:\n",
    "\n",
    "```python\n",
    "def name_of_function():\n",
    "    # block of runnable code\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Why use functions?\n",
    "\n",
    "The main motivation behind using functions is to stay **DRY** - **D**on't **R**epeat **Y**ourself!  \n",
    "\n",
    "Functions are essential to programming because they **simplify** them!  Good functions are simple to reason about, help provide an **abstraction** of that code's purpose, and help **teach** about the nature of the tasks that code is carrying out, and are **testable** (i.e.  they can be checked to see if they are working properly).\n",
    "\n",
    "> The body of a function is again indented, as python uses indentation for grouping statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def say_hi():\n",
    "    print('Hi!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "say_hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Parameters\n",
    "\n",
    "[Parameters](https://docs.python.org/3/glossary.html#term-parameter) are variables that are passed to a function - think of them as placeholders that get assigned when you call the function and you can call your parameters anything!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Example**: Write a function that returns the sum of two numbers.  Use it to add x and y below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def add(a,b):\n",
    "    print(\"a+b: \", a+b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 3\n",
    "y = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Calling function on data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "add(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Returning from function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def say_hi():\n",
    "    'Hello!'\n",
    "\n",
    "print(say_hi()) # None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "What is wrong here?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def say_hi():\n",
    "    print('Hello!')\n",
    "\n",
    "result = say_hi() \n",
    "\n",
    "print(result) # None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This also doesn't seem to work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def say_hi():\n",
    "    return 'Hi!'\n",
    "\n",
    "greeting = say_hi()\n",
    "\n",
    "print(greeting) # 'Hi!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "What's wrong here?\n",
    "\n",
    "```python\n",
    "def sum_even_numbers(list_of_numbers):\n",
    "    total = 0\n",
    "    for number in list_of_numbers:\n",
    "        if number % 2 == 0:\n",
    "            total += number\n",
    "        return total\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A common return mistake is returning too early in a loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Parameters vs variables\n",
    "\n",
    "* A parameter is a variable in a function or method definition.\n",
    "* When a method is called, the [arguments are the data](https://docs.python.org/3/glossary.html#term-argument) you pass into the method's parameters.\n",
    "* [Parameter](https://docs.python.org/3/glossary.html#term-parameter) is variable in the declaration of function.\n",
    "* Argument is the actual value of this variable that gets passed to function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Default values for parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def add(a=10, b=20):\n",
    "    return a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "add() # 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "add(1,10) # 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Having default parameters allows you to avoids errors with incorrect parameters and also generates more readable examples!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Scope\n",
    "\n",
    "- Variables created in functions are scoped in that function! \n",
    "- Arguments are assigned to the named local variables in a function body."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def say_hello():\n",
    "    instructor = 'Colt'\n",
    "    return f'Hello {instructor}'\n",
    "\n",
    "say_hello()\n",
    "\n",
    "print(instructor) # NameError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Keyword arguments\n",
    "\n",
    "When using keyword arguments order does not matter and it provides more flexibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def full_name(first, last):\n",
    "    print (f\"Your name is {first} {last}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "full_name(first='Jane', last='Doe') # Your name is Jane Doe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "full_name(last='Doe', first='Jane') # Your name is Jane Doe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Keyword arguments are different from default parameters\n",
    "\n",
    "* When you **define** a function and use an **=** you are setting a **default parameter**\n",
    "* When you **invoke** a function and use an **=** you are making a **keyword argument**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Documenting functions\n",
    "\n",
    "- use `\"\"\" \"\"\"`  \n",
    "- essential when writing complex functions\n",
    "\n",
    "```python\n",
    "def full_name(first, last):\n",
    "    \"\"\"A function that takes as arguments a first and last name and prints a full name\"\"\"\n",
    "    print (f\"Your name is {first} {last}\")\n",
    "```\n",
    "\n",
    "and adding parameter descriptions using the [numpy style](https://numpydoc.readthedocs.io/en/latest/format.html):\n",
    "\n",
    "```python\n",
    "def full_name(first, last):\n",
    "    \"\"\"A function that takes as arguments a first and last name and prints a full name\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    first : str\n",
    "        The first name of someone.\n",
    "    last : str\n",
    "        The last name of someone.\n",
    "    \"\"\"\n",
    "    print (f\"Your name is {first} {last}\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercises\n",
    "\n",
    "Build functions that carry out that requested task, then use them on the given data. Work in groups for 20mins."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Calculate absolute difference\n",
    "\n",
    "Write a function that returns the absolute (positive) difference between two numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def abs_difference(x, y):\n",
    "    pass # placeholder statement where your code goes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Data: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 25\n",
    "b = 65"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Calculate squares\n",
    "\n",
    "Write a function that returns the square root of the sum of squares of two numbers. \n",
    "\n",
    "> Hint: You can use `math.sqrt` to calculate the square root."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from math import sqrt # see modules and classes notebook for more explanations\n",
    "sqrt(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Indicate sign of difference\n",
    "Write a function that returns \"Positive\" if their difference is positive, and \"Negative\" if their difference is negative"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Calculate sum and differences\n",
    "Write a function that returns **both** the sum of the first two inputs and the difference between the second and third input: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 15\n",
    "c = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Function overloading: Different behaviour for `int` and `str`\n",
    "Write a function that adds two numbers together if the inputs are both numbers, and concatenates the inputs if they are both strings.\n",
    "\n",
    "> Hint: You can use built-in functions [`type`](https://docs.python.org/3/library/functions.html#type) or [`isinstance`](https://docs.python.org/3/library/functions.html#isinstance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = \"Hello\"\n",
    "y = \"World\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using Functions to Wrap Code\n",
    "\n",
    "In general, we want to make code as abstract as possible, but at the same time we should be specific about what we are trying to accomplish.  These two goals - abstraction and specificity - are often at odds with each other.  Encapsulation solves this problem by allowing us to put specific code inside function definitions, and abstract code in the code that calls it.\n",
    "\n",
    "Usually, the process of producing this code format follows three steps:\n",
    "  1. Write code that works.  (Focus on the specifics)\n",
    "  2. Wrap it in a function.  (Encapsulate it)\n",
    "  3. Call the function in your script (Abstract it)\n",
    " \n",
    " \n",
    "For example:\n",
    "```python\n",
    "data = [2, 6, 3, 7, 8, 9, 1]\n",
    "squares = []\n",
    "for el in data:\n",
    "    square = el ** 2\n",
    "    squares.append(square)\n",
    "sum(sum_of_squares)\n",
    "```\n",
    "\n",
    "will become:\n",
    "\n",
    "```python\n",
    "def sum_of_squares(data):\n",
    "    \"\"\"Comute the sum of squares.\"\"\"\n",
    "    squares = []\n",
    "    for el in data:\n",
    "        square = el ** 2\n",
    "        squares.append(square)\n",
    "    return sum(squares)\n",
    "\n",
    "\n",
    "data = [2, 6, 3, 7, 8, 9, 1]\n",
    "sum_of_squares(data)\n",
    "```\n",
    "\n",
    "Let's practice doing this with various types of loops:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercises\n",
    "\n",
    "Take the following working Python code and rewrite it so that it uses functions. Work again in groups for 20mins."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Square numbers\n",
    "The code below squares all of the numbers and removes all of the strings from the list.  Make it into a function, **square_numbers**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "data = [5, \"missing\", 54, \"bad\", 3, 6]\n",
    "good_data = []\n",
    "good_data_squared = []\n",
    "idx = 0\n",
    "while idx < len(data):\n",
    "    el = data[idx]\n",
    "    if isinstance(el, int):\n",
    "        good_data_squared.append(el ** 2)\n",
    "    idx += 1\n",
    "good_data_squared"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Put the modified code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Calculate the standard deviation\n",
    "The code below calculates the **standard deviation** of the data.  Put it in a function called **`standard_deviation`** and use the function on the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "data = [2, 6, 8, 2, 5, 8, 9, 2]\n",
    "\n",
    "mean = 0\n",
    "std = 0\n",
    "for el in data:\n",
    "    mean += el / len(data)\n",
    "dev_squareds = []\n",
    "for el in data:\n",
    "    dev = (el - mean) ** 2\n",
    "    dev_squareds.append(dev)\n",
    "sum_dev_squareds = sum(dev_squareds)\n",
    "standard_dev = sum_dev_squareds / len(data) * 1.\n",
    "standard_dev = math.sqrt(standard_dev)\n",
    "standard_dev"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Put the modified code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Bootstrap mean\n",
    "The code below generates a **bootstrap** sample of the data, getting a random selection of the data **boot_n** times and calculating the mean of that sample, so that many estimates of the mean can be made from a single dataset.  Put it in a function called **bootstrap_means**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "data = [2, 6, 8, 2, 5, 8, 9, 2, 6, 2, 10]\n",
    "n_boot = 5\n",
    "means = []\n",
    "for rep in range(n_boot):\n",
    "    sample = random.choices(data, k=len(data))\n",
    "    mean = sum(sample) / len(sample)\n",
    "    rep = rep * 2\n",
    "    means.append(mean)\n",
    "means\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Put the modified code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Warning: Don't use mutable types as default parameters\n",
    "\n",
    "- do not use e.g. an empty list a a default parameter, use `None`\n",
    "\n",
    "```python\n",
    "def add_number(x, to=None):\n",
    "    \"\"\"add x to a list of numbers. Create a new list if none is passed.\"\"\"\n",
    "    \n",
    "    if to is None:\n",
    "        to = []\n",
    "    to.append(x)\n",
    "    return to\n",
    "\n",
    "my_numbers = add_number(4)\n",
    "\n",
    "add_number(9, to=my_numbers)\n",
    "print(my_numbers)\n",
    "```\n",
    "\n",
    "> More prominent examples arise out of the context of classes (next topic), e.g. see Ramalho 2015: Fluent Python, p. 236ff."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# example from last section \"Using Function to Wrap your code\"\n",
    "\n",
    "def sum_of_squares(data, squares = []):\n",
    "    for el in data:\n",
    "        square = el ** 2\n",
    "        squares.append(square)\n",
    "    # replace one statement\n",
    "    # return sum(squares)\n",
    "    return squares\n",
    " \n",
    "\n",
    "data = [2, 6, 3]\n",
    "sum_of_squares(data) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "data = [7, 8, 9, 1]\n",
    "sum_of_squares(data, squares=[])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Refactoring Code: Improving it without breaking it\n",
    "\n",
    "By modularizing code, we give ourselves the ability to modify small parts of the code without having to worry about the rest of it--so long as the inputs and outputs don't change, anything that happens in the middle doesn't matter to the code that calls the function!\n",
    "\n",
    "The exercises above all contain things that can be improved, whether that is to make them simpler, more readable, or more reliable, any improvements are helpful.  Let's work through them again and make the following improvements:\n",
    "\n",
    "  1. **Remove Orphan Code**: Often, code that isn't actually used by the function is left sitting there, lost and forgotten.  Deleting those lines will make it easier to see how everything works and improve readability.\n",
    "  2. **Change variable names to something clearer**: variables like x and y are not helpful.  Make them something that represents that result of the line!\n",
    "  3. **Reduce the number of steps**: If there are several lines doing something you think is simple, either compress them to a single line or make a new function that represents that action.  If you know that the function you want already exists in another package, then import that package and use it!\n",
    "  4. **Convert While loops to For loops**: If you see iteration happening, use a for-loop!  If it's a single action, why not make it a comprehension?\n",
    "  \n",
    "**Exercises** Refactor the functions created in the previous section.  Make sure to re-run the code with each change you make to verify that it still works!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.8.3"
  },
  "rise": {
   "scroll": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "232.997px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}