13_python_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data science in Python\n",
    "\n",
    "- Course GitHub repo: https://github.com/pycam/python-data-science\n",
    "- Python website: https://www.python.org/ \n",
    "\n",
    "## Session 1.3: Creating functions and modules to write reusable code\n",
    "\n",
    "- [Building reusable and modular code with functions](#Building-reusable-and-modular-code-with-functions)\n",
    "    - [Exercise 1.3.1](#Exercise-1.3.1)\n",
    "    - [Exercise 1.3.2](#Exercise-1.3.2)\n",
    "- [Create your own module](#Create-your-own-module)\n",
    "    - [Exercise 1.3.3](#Exercise-1.3.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mind map\n",
    "\n",
    "<img src=\"img/mind_maps/mind_maps.003.jpeg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building reusable and modular code with functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we’ve used Python to explore and manipulate individual datasets by hand, much like we would do in a spreadsheet. The beauty of using a programming language like Python, though, comes from the ability to automate data processing through the use of loops and functions.\n",
    "\n",
    "Suppose now that we would like to calculate the average GDP per capita, its median and standard deviation for all continents over all the years. We could write specific conditions for each case, and write the same code over again for the different situation but that would be time consuming, error prone and hard to maintain. A more elegant solution would be to create a **reusable tool** that performs this task with minimum input from the user. To do this, we are going to turn the code we’ve already written into a **function**.\n",
    "\n",
    "Functions are reusable, self-contained pieces of code that are called with a single command. They can be designed to accept arguments as input and return values, but they don’t need to do either. Variables declared inside functions only exist while the function is running and if a variable within the function (a local variable) has the same name as a variable somewhere else in the code, the local variable hides but doesn’t overwrite the other.\n",
    "\n",
    "Every method used in Python (for example, **`print()`**) is a function, and the libraries we import (say, `csv` or `os`) are a collection of functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will first use functions that are housed within the same code that uses them, and then create our own module to write functions that can be used by different programs.\n",
    "\n",
    "### Function definition\n",
    "\n",
    "Functions are declared following this general structure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def this_is_the_function_name(input_argument1, input_argument2):\n",
    "\n",
    "    # The body of the function is indented\n",
    "    # This function prints the two arguments to screen\n",
    "    print('The function arguments are:', input_argument1, input_argument2, '(this is done inside the function!)')\n",
    "\n",
    "    # And returns their product\n",
    "    return input_argument1 * input_argument2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function declaration starts with the word **`def`**, followed by the function name and any arguments in parenthesis, and ends with a colon. The body of the function is indented just like loops are. If the function returns something when it is called, it includes a **`return`** statement at the end.\n",
    "\n",
    "Once the `return` statement is reached the operation of the function ends, and anything on the return line is passed back as output.\n",
    "\n",
    "### Function call\n",
    "\n",
    "This is how we call the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product_of_inputs = this_is_the_function_name(2, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Their product is:', product_of_inputs, '(this is done outside the function!)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function arguments\n",
    "If we change the values of the arguments when calling the function, then its output changes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product_of_inputs = this_is_the_function_name(4, 7)\n",
    "print('Their product is:', product_of_inputs, '(this is done outside the function!)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we call the function by giving it the wrong number of arguments (not 2), we get a `TypeError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product_of_inputs = this_is_the_function_name(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The arguments we have passed to the function so far have all been **mandatory**, if we do not supply them or if supply the wrong number of arguments Python will throw an error.\n",
    "\n",
    "**Mandatory arguments are assumed to come in the same order as the arguments in the function definition**, but you can also opt to specify the arguments using the argument names as _keywords_, supplying the values corresponding to each keyword with a `=` sign."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product_of_inputs = this_is_the_function_name(input_argument1=3, input_argument2=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product_of_inputs = this_is_the_function_name(input_argument2=3, input_argument1=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**BEWARE!** Unnamed (positional) arguments must come before named (keyword) arguments, otherwise we will get a `SyntaxError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product_of_inputs = this_is_the_function_name(3, input_argument2=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product_of_inputs = this_is_the_function_name(input_argument2=2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function returned values\n",
    "\n",
    "If we call the function by not assigning the function call to a variable (`product_of_inputs =`), we are unable to retrieve the output of the function passed back via the `return` statement, but the code within the function is still executed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "this_is_the_function_name(4, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function written so far has returned only a single value, however it is possible to pass back more than one value via the `return` statement. In the following example, we change the function that takes two arguments and passes back three values: the total, the difference and the product of these two arguments. The return values are really passed back inside a single tuple, which can be caught as a single collection of values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def this_is_the_function_name_returning_multiple_values(input_argument1, input_argument2):\n",
    "    \n",
    "    total = input_argument1 + input_argument2\n",
    "    difference = input_argument1 - input_argument2\n",
    "    product = input_argument1 * input_argument2\n",
    "    \n",
    "    return total, difference, product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "returned_collection = this_is_the_function_name_returning_multiple_values(2, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(returned_collection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_of_inputs, difference_of_inputs, product_of_inputs = this_is_the_function_name_returning_multiple_values(2, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(total_of_inputs, difference_of_inputs, product_of_inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There can be more than one `return` statement in a function, although typically there is only one, at the end of the function. The `return` keyword immediately exits the function, and no more of the code in that function will be run once the function has returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def this_is_the_function_name(input_argument1, input_argument2):\n",
    "\n",
    "    # The body of the function is indented\n",
    "    \n",
    "    # This is a variable inside the function\n",
    "    variable_inside_function = '(this is done inside the function!)'\n",
    "\n",
    "    # And returns their product\n",
    "    return input_argument1 * input_argument2\n",
    "\n",
    "    # This function does not print the two arguments to screen (no code executed after return statement)\n",
    "    print('The function arguments are:', input_argument1, input_argument2, variable_inside_function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product_of_inputs = this_is_the_function_name(4, 7)\n",
    "print('Their product is:', product_of_inputs, '(this is done outside the function!)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function variable scope\n",
    "\n",
    "If we declare a variable inside the function, it is a local variable only visible within the function, we are therefore unable to access it outside the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def this_is_the_function_name(input_argument1, input_argument2):\n",
    "\n",
    "    # The body of the function is indented\n",
    "    \n",
    "    # This is a variable inside the function\n",
    "    variable_inside_function = '(this is done inside the function!)'\n",
    "\n",
    "    # This function prints the two arguments to screen\n",
    "    print('The function arguments are:', input_argument1, input_argument2, variable_inside_function)\n",
    "    \n",
    "    # And returns their product\n",
    "    return input_argument1 * input_argument2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product_of_inputs = this_is_the_function_name(5, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(variable_inside_function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(product_of_inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a variable is declared both inside and outside the function using the same name, only the value of the outside variable (the global one) is visible and accessible, changing it within the function does not change it outside:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable_inside_and_outside_function = 'this is a variable created outside the function'\n",
    "\n",
    "def this_is_the_function_name(input_argument1, input_argument2):\n",
    "\n",
    "    # The body of the function is indented\n",
    "    \n",
    "    # This is a variable inside the function\n",
    "    variable_inside_function = '(this is done inside the function!)'\n",
    "    \n",
    "    # This is a variable created outside and modified inside the function\n",
    "    variable_inside_and_outside_function = 'this is a variable changed inside the function'\n",
    "    print(variable_inside_and_outside_function)\n",
    "\n",
    "    # This function prints the two arguments to screen\n",
    "    print('The function arguments are:', input_argument1, input_argument2, variable_inside_function)\n",
    "    \n",
    "    # And returns their product\n",
    "    return input_argument1 * input_argument2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**BEWARE!** When using Jupyter Notebooks and modifying a function, you MUST re-run that cell in order for the changed function to be available to the rest of the code. Nothing will visibly happen when you do this, though, because simply defining a function without calling it doesn’t produce an output. Any cells that use the now-changed functions will also have to be re-run for their output to change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "product_of_inputs = this_is_the_function_name(10, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(variable_inside_and_outside_function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function documentation\n",
    "\n",
    "The text between the two sets of triple double quotes is called a **docstring** and contains the documentation for the function. It does nothing when the function is running and is therefore not necessary, but it is good practice to include docstrings as a reminder of what the code does. Docstrings in functions also become part of their ‘official’ documentation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def this_is_the_function_name(input_argument1, input_argument2):\n",
    "    \"\"\"\n",
    "    This is the documentation of the function.\n",
    "    Returns the product of the two arguments.\n",
    "    \n",
    "    input_argument1 --- first input argument \n",
    "    input_argument2 --- second input argument\n",
    "    \"\"\"\n",
    "\n",
    "    # The body of the function is indented\n",
    "    # This function prints the two arguments to screen\n",
    "    print('The function arguments are:', input_argument1, input_argument2, '(this is done inside the function!)')\n",
    "\n",
    "    # And returns their product\n",
    "    return input_argument1 * input_argument2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(this_is_the_function_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.3.1\n",
    "\n",
    "- Write a function that takes two arguments and returns their mean. \n",
    "    - Give your function a meaningful name, and a good documentation. \n",
    "    - Call your function multiple times with different values, and once using the keyword arguments with their associated values.\n",
    "    - Print the result of these different function calls.\n",
    "- Write another function that takes a list as argument and returns the mean and the median of all the numbers in the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing our own function\n",
    "\n",
    "We can now turn our code for calculating the average GDP per capita, its median and standard deviation for all continents over all the years into a function. \n",
    "\n",
    "Here is the original code we wrote:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import statistics as stats\n",
    "import csv\n",
    "eu_gdppercap_1962 = []\n",
    "americas_gdppercap_1962 = []\n",
    "with open(os.path.join('data', 'gapminder.csv')) as f:\n",
    "    reader = csv.DictReader(f, delimiter = \",\")\n",
    "    for data in reader:        \n",
    "        if data['year'] == \"1962\":\n",
    "            if data['continent'] == \"Europe\":\n",
    "                eu_gdppercap_1962.append(float(data['gdpPercap']))\n",
    "            if data['continent'] == 'Americas':\n",
    "                americas_gdppercap_1962.append(float(data['gdpPercap']))\n",
    "                \n",
    "\n",
    "print('European GDP per Capita in 1962')\n",
    "print(eu_gdppercap_1962)\n",
    "print('average:', stats.mean(eu_gdppercap_1962))\n",
    "print('median:', stats.median(eu_gdppercap_1962))\n",
    "print('standard deviation:', stats.stdev(eu_gdppercap_1962))\n",
    "\n",
    "print('American GDP per Capita in 1962')\n",
    "print(americas_gdppercap_1962)\n",
    "print('average:', stats.mean(americas_gdppercap_1962))\n",
    "print('median:', stats.median(americas_gdppercap_1962))\n",
    "print('standard deviation:', stats.stdev(americas_gdppercap_1962))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s first write a function that filters data for a continent and a specific year, and calculates the average, median and standard deviation of the GDP of the countries of this continent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics as stats\n",
    "import csv\n",
    "\n",
    "def gdp_stats_by_continent_and_year(gapminder_filepath, continent, year):\n",
    "    \"\"\"\n",
    "    Returns a dictionary of the average, median and standard deviation of GDP per capita \n",
    "    for all countries of the selected continent for a given year.\n",
    "\n",
    "    gapminder_filepath --- gapminder file path with multi-continent and multi-year data\n",
    "    continent --- continent for which data is extracted\n",
    "    year --- year for which data is extracted\n",
    "    \"\"\"\n",
    "    gdppercap = []\n",
    "    with open(gapminder_filepath) as f:\n",
    "        reader = csv.DictReader(f, delimiter = \",\")\n",
    "        for data in reader: \n",
    "            if data['continent'] == continent and data['year'] == year:\n",
    "                gdppercap.append(float(data['gdpPercap']))\n",
    "    print(continent, 'GDP per Capita in', year)\n",
    "    return {'mean': stats.mean(gdppercap), 'median': stats.median(gdppercap), 'stdev': stats.stdev(gdppercap)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(gdp_stats_by_continent_and_year)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os       \n",
    "gdp_stats = gdp_stats_by_continent_and_year(os.path.join('data', 'gapminder.csv'), 'Europe', '1962')\n",
    "print(gdp_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os       \n",
    "gdp_stats = gdp_stats_by_continent_and_year(os.path.join('data', 'gapminder.csv'), 'Europe', '2007')\n",
    "print(gdp_stats['mean'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os       \n",
    "gdp_stats = gdp_stats_by_continent_and_year(os.path.join('data', 'gapminder.csv'), 'Americas', '1962')\n",
    "print(gdp_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os       \n",
    "gdp_stats = gdp_stats_by_continent_and_year(os.path.join('data', 'gapminder.csv'), 'Africa', '1962')\n",
    "print(gdp_stats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function arguments with default values\n",
    "\n",
    "The functions we wrote demand that we give them a value for every argument. Ideally, we would like these functions to be as flexible and independent as possible. \n",
    "\n",
    "Let’s modify the function `gdp_stats_by_continent_and_year` so that the `continent` and `year` default to `Europe` and `1952` if they are not supplied by the user. We can do this by assigning some value to the named argument with the `=` operator in the function definition.\n",
    "\n",
    "Any arguments in the function without default values (here, `gapminder_filepath`) is a required argument and MUST come before the argument with default values (which are optional in the function call)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics as stats\n",
    "import csv\n",
    "\n",
    "def gdp_stats_by_continent_and_year(gapminder_filepath, continent='Europe', year='1952'):\n",
    "    \"\"\"\n",
    "    Returns a dictionary of the average, median and standard deviation of GDP per capita \n",
    "    for all countries of the selected continent for a given year.\n",
    "\n",
    "    gapminder_filepath --- gapminder file path with multi-continent and multi-year data\n",
    "    continent --- continent for which data is extracted\n",
    "    year --- year for which data is extracted\n",
    "    \"\"\"\n",
    "    gdppercap = []\n",
    "    with open(gapminder_filepath) as f:\n",
    "        reader = csv.DictReader(f, delimiter = \",\")\n",
    "        for data in reader: \n",
    "            if data['continent'] == continent and data['year'] == year:\n",
    "                gdppercap.append(float(data['gdpPercap']))\n",
    "    print(continent, 'GDP per Capita in', year)\n",
    "    return {'mean': stats.mean(gdppercap), 'median': stats.median(gdppercap), 'stdev': stats.stdev(gdppercap)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os       \n",
    "gdp_stats = gdp_stats_by_continent_and_year(os.path.join('data', 'gapminder.csv'))\n",
    "print(gdp_stats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.3.2\n",
    "\n",
    "- Generalise the code written for exercise 1.1.3 for finding which European countries have the largest population in 1952 and 2007 by creating a function that finds which country on a defined continent has the largest population for a given year. Provide default values for certain arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create your own module\n",
    "\n",
    "So far we have been writing Python code in files as executable scripts without knowing that they are also modules from which we are able to call the different functions defined in them.\n",
    "\n",
    "A module is a file containing Python definitions and statements. The file name is the module name with the suffix `.py` appended. Create a file called `this_is_the_module_name.py` in the current directory with the function `this_is_the_function_name()` written earlier as its contents:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def this_is_the_function_name(input_argument1, input_argument2):\n",
    "    \"\"\"\n",
    "    This is the documentation of the function.\n",
    "    Returns the product of the two arguments.\n",
    "    \n",
    "    input_argument1 --- first input argument \n",
    "    input_argument2 --- second input argument\n",
    "    \"\"\"\n",
    "\n",
    "    # The body of the function is indented\n",
    "    # This function prints the two arguments to screen\n",
    "    print('The function arguments are:', input_argument1, input_argument2, '(this is done inside the function!)')\n",
    "\n",
    "    # And returns their product\n",
    "    return input_argument1 * input_argument2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now open a terminal windown, enter into the Python interpreter from the directory you've created `this_is_the_module_name.py` file and import it:\n",
    "\n",
    "```\n",
    "python3\n",
    "Python 3.6.4 (default, Jan 21 2018, 20:11:12) \n",
    "[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.42.1)] on darwin\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> import this_is_the_module_name\n",
    ">>> product_of_inputs = this_is_the_module_name.this_is_the_function_name(10, 3)\n",
    "The function arguments are: 10 3 (this is done inside the function!)\n",
    ">>> print(product_of_inputs)\n",
    "30\n",
    ">>>\n",
    "```\n",
    "\n",
    "If you wish to import it into this notebook, below is what you need to do. If you wish to edit the module file and change the code or add another function, you will have to restart the notebook to have these changes taken into account using the restart the kernel button in the menu bar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this_is_the_module_name\n",
    "product_of_inputs = this_is_the_module_name.this_is_the_function_name(10, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A module can contain executable statements as well as function definitions. These statements are intended to initialize the module. They are executed only the first time the module name is encountered in an import statement. \n",
    "They are also run if the file is executed as a script.\n",
    "\n",
    "Do comment out these executable statements if you do not wish to have them executed when importing your module.\n",
    "\n",
    "For more information about modules, https://docs.python.org/3/tutorial/modules.html."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.3.3\n",
    "\n",
    "- Create a module with the two functions written so far to analyse the Gapminder dataset. Import the module, and call these functions multiple times with different arguments.\n",
    "- Create a new function in this module that returns the average life expectancy on a given continent for a given year. Call this function with different arguments and compare the results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next session: see you tomorrow!\n",
    "\n",
    "Go to our next notebook: [Introduction to Day 2](20_python_data_intro.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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}