lecture_08_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align: center\">\n",
    "    <div style=\"font-size: xxx-large ; font-weight: 900 ; color: rgba(0 , 0 , 0 , 0.8) ; line-height: 100%\">\n",
    "        Functions\n",
    "    </div>\n",
    "    <div style=\"font-size: x-large ; padding-top: 20px ; color: rgba(0 , 0 , 0 , 0.5)\">\n",
    "        What + Why\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "Programming languages that support functions, which do not change state (variables) outside the function, are called \"functional\".\n",
    "\n",
    "## What is a function?\n",
    "A function accepts zero or more parameters and can\n",
    "\n",
    "    - compute something,\n",
    "    - return a result,\n",
    "    - change external state (but it should not do so as it can make understanding their purpose difficult).\n",
    "\n",
    "## Why do we have functions?\n",
    "\n",
    "Functions allow us to **reuse code**.\n",
    "\n",
    "**Example:**  \n",
    "Imagine you want to write a short program that computes the area of a circle given its radius. The mathematical equation is $area(r) = \\pi r^2$\n",
    "\n",
    "You could write in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "pi = 3.141592653589793\n",
    "\n",
    "r = 10\n",
    "area = pi * r**2 # Remember, ** computes r raised to the power of 2 or r*r\n",
    "print(area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can compute the area of a circle for `r=10`. But what if you would like to do it for a different `r`.\n",
    "\n",
    "You have two options now:\n",
    "1. You copy your previous code, which can quickly become very messy.\n",
    "\n",
    "```python\n",
    "pi = 3.141592653589793\n",
    "\n",
    "r = 10\n",
    "area = pi * r**2\n",
    "print(area)\n",
    "\n",
    "r = 20\n",
    "area = pi * r**2\n",
    "print(area)\n",
    "```\n",
    "2. Or, you create a function that accepts `r` as an argument and computes the corresponding area for any `r`.\n",
    "\n",
    "**Functions help us to create building blocks from our code that we can reuse without the need to duplicate code.**\n",
    "\n",
    "A new implementation could look like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "314.1592653589793\n",
      "1256.6370614359173\n",
      "78.53981633974483\n"
     ]
    }
   ],
   "source": [
    "def area_of_a_circle(r):\n",
    "    pi = 3.141592653589793\n",
    "    area = pi * r**2\n",
    "    return area\n",
    "\n",
    "print(area_of_a_circle(10))\n",
    "print(area_of_a_circle(20))\n",
    "print(area_of_a_circle(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This also has the benefit of describing what our code does in the function name. By reading `area_of_a_circle` we can infer that the above code probably computes exactly that.\n",
    "\n",
    "## How to name functions?\n",
    "\n",
    "In Python the general rule is to name functions in **snake case**.\n",
    "\n",
    "That means you would come up with a short phrase that describes what your function does.\n",
    "\n",
    "Something like **\"computes area of a circle\"** and then combine theses words with underscores \"\\_\" so you will get **\"computes_area_of_a_circle\"**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The general syntax of a function is\n",
    "\n",
    "![](images/function_signature.png)\n",
    "\n",
    "1. The **def** keyword will tell python that this is a function.\n",
    "\n",
    "2. This is the **function name** (snake case), e.g. *area_of_a_circle*.\n",
    "\n",
    "3. **positional arguments** are **mandatory**.\n",
    "  - A function can have 0 or arbitrarily many positional arguments.\n",
    "  - Positional arguments are always the first arguments in the list of all arguments.\n",
    "  - When calling a function you have to specify their values in the same order as they appear within the two green parenthesis.\n",
    "    - If your function looks like this:  \n",
    "    ```python\n",
    "    def area_of_a_circle(positional_argument_1, positional_argument_2):\n",
    "    ```  \n",
    "    you have to call it with  \n",
    "    ```python\n",
    "    area_of_a_circle(10, 5)\n",
    "    ```\n",
    "\n",
    "4. **keyword arguments** are **optional**, because they already have a default value assigned to them.\n",
    "  - A function can have 0 or arbitrarily many keyword arguments.\n",
    "  - Keyword arguments are sometimes referred to as **kwargs**.\n",
    "  - Keyword arguments always appear after the positional arguments (that's why they are called positional ;).\n",
    "  - When calling a function you can provide keyword arguments using their names (keywords) followed by an \"=\" and the value you want to give it: `keyword_argument=10`.\n",
    "      - Order does not matter when passing values to a function in this way (the same works for positional arguments)\n",
    "      ```python\n",
    "      def area_of_a_circle(kwarg_1=0, kwarg_2=0):\n",
    "      ```  \n",
    "      you can call it with\n",
    "      ```python\n",
    "      area_of_a_circle(kwarg_2=10, kwarg_1=5):\n",
    "      ```  \n",
    "5. ***args** is optional. It is a tuple in which Python will automatically store all unknown **positional arguments** passed to a function. Meaning, they have no name within the green parenthesis.\n",
    "\n",
    "6. ****kwargs** is optional. It is a dictionary in which Python will automatically store all unknown **keyword arguments** passed to a function. Meaning, they have no name within the green parenthesis.\n",
    "\n",
    "7. **Function Body** is where your code goes. This is indented by spaces or a tab to help Python understand that this code belong to the function. Your code here can access the arguments of the function.\n",
    "\n",
    "8. **return** is optional. This keyword in combination with a variable or value (e.g. `return area`) will tell Python to \"return\" a value to whoever called the function. By default, if you do not add an explicit `return` Python will return `None`. Note: You can also use a single `return` without a variable to exit (return from) a function at any point.\n",
    "\n",
    "\n",
    "## Why do we have these different types of arguments?\n",
    "\n",
    "You can think about **positional arguments** as being *required* to run your function and **keyword arguments** as being *optional* or *default* values that only slightly change the behavior of your function.\n",
    "\n",
    "## How do we execute functions?\n",
    "\n",
    "A function can be executed by its name followed by parenthesis and a comma separated list of various arguments `function_name(agument1, argument2, ...)`.\n",
    "\n",
    "## Let's look at some examples\n",
    "\n",
    "### Just a function\n",
    "This does nothing on its own"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function():\n",
    "    print(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions without `arguments`\n",
    "We have to \"call\" that function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "def function():\n",
    "    print(1)\n",
    "    \n",
    "function() # Will print 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions with `positional arguments`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "def function_1_positional(print_value):\n",
    "    print(print_value)\n",
    "    \n",
    "function_1_positional('Hello World')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World 2\n",
      "2 Hello World\n",
      "Hello World 2\n"
     ]
    }
   ],
   "source": [
    "def function_2_positional(print_value, number):\n",
    "    print(print_value, number)\n",
    "    \n",
    "function_2_positional('Hello World', 2)\n",
    "function_2_positional(2, 'Hello World')\n",
    "function_2_positional(number=2, print_value='Hello World') # You can provide them with the syntax of keyword arguments, then order does not matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "function_2_positional() missing 1 required positional argument: 'number'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m--------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m              Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-7-8f7ae1d3741f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfunction_2_positional\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Hello World'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# This does not work, missing second positional argument\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: function_2_positional() missing 1 required positional argument: 'number'"
     ]
    }
   ],
   "source": [
    "function_2_positional('Hello World') # This does not work, missing second positional argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions with `optional arguments`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hello Earth\n"
     ]
    }
   ],
   "source": [
    "def function_1(print_value='Hello World'):\n",
    "    print(print_value)\n",
    "    \n",
    "function_1()\n",
    "function_1('Hello Earth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World 2\n",
      "Hello World 50\n",
      "Hi 40\n",
      "Hello Earth 3\n"
     ]
    }
   ],
   "source": [
    "def function_2(print_value='Hello World', number=2):\n",
    "    print(print_value, number)\n",
    "    \n",
    "function_2() # Use the defaults\n",
    "function_2(number=50) # You can also just specify some of them\n",
    "function_2(number=40, print_value='Hi') # When using the argument names order does not matter\n",
    "function_2('Hello Earth', 3) # If you list the arguments without their name, then Python will match them in order like positional arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions with both `positional arguments` and `optional arguments`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi how 10 None\n",
      "Hi how are None\n",
      "Hi how are you\n",
      "Hi how are you\n"
     ]
    }
   ],
   "source": [
    "def function_mixed(first, second, optional_third=10, optional_fourth=None):\n",
    "    print(first, second, optional_third, optional_fourth)\n",
    "\n",
    "function_mixed('Hi', 'how',)\n",
    "function_mixed('Hi', 'how', 'are',)\n",
    "function_mixed('Hi', 'how', 'are', 'you')\n",
    "function_mixed('Hi', 'how', 'are', optional_fourth='you')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "function_mixed() missing 1 required positional argument: 'second'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m--------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m              Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-967e7e6745fb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfunction_mixed\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Hi'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: function_mixed() missing 1 required positional argument: 'second'"
     ]
    }
   ],
   "source": [
    "function_mixed('Hi')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!!! **You have to always follow the rule: positional arguments first, optional arguments last**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (<ipython-input-12-7fed0f8095a4>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-12-7fed0f8095a4>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    def function_mixed(positional_first, optional_second=10, positional_third, optional_fourth=None):\u001b[0m\n\u001b[1;37m                      ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "def function_mixed(positional_first, optional_second=10, positional_third, optional_fourth=None):\n",
    "    print(positional_first, optional_second, positional_third, optional_fourth)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function without `return`\n",
    "By default Python will add a \"hidden\" `return None` to the end of a function if you do not provide it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def compute(a, b):\n",
    "    a + b * 2\n",
    "\n",
    "result = compute(5, 2)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function with `return`\n",
    "`return` can be used to return a single or multiple values from a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compute(a, b):\n",
    "    return a + b * 2\n",
    "\n",
    "compute(5, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple values can be returned by listing them separated by commas.  \n",
    "Python will automatically wrap/pack these values into a **tuple**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(314.1592653589793, 3.141592653589793, 100)\n",
      "Type of result is: <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def area_of_a_circle(r):\n",
    "    pi = 3.141592653589793\n",
    "    r_squared = r**2\n",
    "    area = pi * r_squared\n",
    "    return area, pi, r_squared\n",
    "\n",
    "result = area_of_a_circle(10)\n",
    "print(result)\n",
    "print('Type of result is:', type(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \\*args and \\*\\*kwargs\n",
    "\n",
    "**\\*args** is a shorthand for **arguments** or **positional arguments**\n",
    "\n",
    "- **\\*args** will capture all positional arguments which are not already captured by an explicitly named positional argument.\n",
    "- Because **\\*args** is a **tuple** you can access values in **\\*args** with **args[0]** as described in [Lecture 07 - Container - Tuple](lecture_07_container.ipynb#<code>Tuple<%2Fcode>)\n",
    "\n",
    "**\\*\\*kwargs** is a shorthand for **keyword arguments**\n",
    "\n",
    "- **\\*\\*kwargs** will capture all optional arguments which are not already captured by an explicit optional argument.\n",
    "- Because **\\*\\*kwargs** is a **dict** you can access values in **\\*\\*kwargs** with **kwargs[keyword]** as described in [Lecture 07 - Container - Dict](lecture_07_container.ipynb#<code>Dict<%2Fcode>)\n",
    "\n",
    "We won't go into the details here but in general both concepts are useful when you want one or multiple of the following:\n",
    "\n",
    "- A function that accepts an arbitrary amount of arguments.\n",
    "- Allow a function to accept values that it can pass to other functions it calls (often used with \\*\\*kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function with \\*args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "(1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "def function_with_args(print_value, *args):\n",
    "    print(print_value)\n",
    "    print(args)\n",
    "    \n",
    "function_with_args('Hello World', 1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "45\n"
     ]
    }
   ],
   "source": [
    "def sum_values(*args):\n",
    "    total = 0\n",
    "    for value in args:\n",
    "        total += value\n",
    "    return total\n",
    "\n",
    "print(sum_values(1,2,3,4))\n",
    "print(sum_values(1,2,3,4,5,6,7,8,9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function with \\*\\*kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kwargs: {'text': 'Hello World', 'a': 1, 'b': 2, 'c': 3, 'd': 4}\n"
     ]
    }
   ],
   "source": [
    "def function_with_kwargs(**kwargs):\n",
    "    print('kwargs:', kwargs)\n",
    "    \n",
    "function_with_kwargs(text='Hello World', a=1, b=2, c=3, d=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A function with both \\*args and \\*\\*kwargs will accept __everything__ as input**\n",
    "\n",
    "**Note**: If you want to use \\*args and \\*\\*kwargs and keyword arguments you have to specify the keyword arguments **after** \\*args ! (here `optional_after_args=2`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_with_both(print_value, *args, optional_after_args=2, **kwargs):\n",
    "    print('print_value:', print_value)\n",
    "    print('Optional:', optional_after_args)\n",
    "    print('args:', args)\n",
    "    print('kwargs:', kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "print_value: Hello World\n",
      "Optional: 2\n",
      "args: ()\n",
      "kwargs: {'a': 1, 'b': 2, 'c': 3, 'd': 4}\n"
     ]
    }
   ],
   "source": [
    "function_with_both('Hello World', a=1, b=2, c=3, d=4)\n",
    "# Notice how 'Hello World' will not be in `args`, because it is a positional argument already"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "print_value: Everything\n",
      "Optional: 4\n",
      "args: (2, 2, 3, 4)\n",
      "kwargs: {'a': 10, 'b': 10, 'd': 5}\n"
     ]
    }
   ],
   "source": [
    "function_with_both('Everything', 2, 2, 3, 4, a=10, b=10, d=5, optional_after_args=4)\n",
    "# Notice how everything up to the first keyword argument is in *args, except the first positional argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus 2 + Warning\n",
    "\n",
    "Be careful, functions can access values that are declared outside of their body."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "outside = 10\n",
    "\n",
    "def function():\n",
    "    print(outside)\n",
    "    \n",
    "function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you declare a new variable inside the function with the same name it will **overshadow** the outside one. It will not override it though!\n",
    "\n",
    "This can sometimes be useful but it can also quickly lead to erroneous code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"outside\" variable inside \"function\": 5\n",
      "\"outside\" variable:\" 10\n"
     ]
    }
   ],
   "source": [
    "outside = 10\n",
    "\n",
    "def function():\n",
    "    outside = 5\n",
    "    print('\"outside\" variable inside \"function\":', outside)\n",
    "    \n",
    "function()\n",
    "print('\"outside\" variable:\"', outside)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**BUT**, outside code cannot access values within a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'inside' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m--------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m              Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-24-081a382ee6a1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mfunction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minside\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# This will not work\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'inside' is not defined"
     ]
    }
   ],
   "source": [
    "def function():\n",
    "    inside = 5\n",
    "    print(inside)\n",
    "    \n",
    "function()\n",
    "print(inside) # This will not work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summary\n",
    "\n",
    "* You know **what a function is**.\n",
    "* You understand **why functions are useful**.\n",
    "* You know the **syntax of a function** (def ...).\n",
    "* You know the **different arguments of a function** (positional, keyword).\n",
    "* You know what **return** does and how to use it to return one or multiple values from a function.\n",
    "\n",
    "Bonus\n",
    "* You have learned how to use **\\*args** and **\\*\\*kwargs**.\n",
    "* You know about **accessing variables outside a function** and **shaddowing outside variables** and that you have to be mindful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Next excercise: [Exercise 08](exercise_08_functions.ipynb)\n",
    "### Next lecture: [Python - Classes](lecture_09_classes.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}