03-function_definition-skeleton.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function definitions\n",
    "\n",
    "`python` contains a whole range of predefined functions which make is very versatile. We have been using some in the previous sections. However there will always be some functionality that is missing. That is when you need to write your own functions.\n",
    "\n",
    "We will explain the basics of what a function is, why you would write a function, that it (usually) takes inputs, then performs an operation on those inputs before returning some output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## def\n",
    "\n",
    "You declare your intentions to write a function with the `def` statement, followed by the name of the function, which you can choose to be anything (but remember to be informative!), followed by parentheses that include the parameters of the function. Finally a semicolon and a newline to an indented block of code will represent the body of the function where the operation is performed.\n",
    "\n",
    "One of the most barebone functions that you could imageine would look something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello_world():\n",
    "    print('Hello World!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then call this function, like any other function that comes with python. Remember to put the parentheses!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello_world()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## parameters\n",
    "\n",
    "This function is obviously not very useful. Let's allow it take some input. In order to declate this, we will put a variable name into the parentheses called `city`. Now as we call the function, we can pass any string to this parameter `city` and it will be accessible in the body of the function. It will be a variable `city` that you can print with `.format()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello_city(city):\n",
    "    print('Hello {}!'.format(city))\n",
    "\n",
    "hello_city('London')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that you just needed to call it with `hello_city('London')`. Alternatively you could give the name of the parameter. This might be more verbose, however it makes your intention clearer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello_city(city='Paris')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible define multiple inputs. In this case is becomes especially useful to use the names of the parameters as we call the function in order to show our intentions. In this case, the order of parameters is unimportant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello_address(city, country):\n",
    "    print('Hello {} in {}!'.format(city, country))\n",
    "    \n",
    "hello_address(country='United States of America', city='New York')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also give variables default values. This allows us to assume the value of a variable, unless it is specified in the fuction call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello_address(city, country='United Kindom'):\n",
    "    print('Hello {} in {}!'.format(city, country))\n",
    "    \n",
    "hello_address(city='London')\n",
    "hello_address(country='United States of America', city='New York')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "If you do not know what parameters a function takes, you can use the `tab` key to show you a list of options. The same applies to the function names as well.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise - Declaring a function\n",
    "\n",
    "Write your own function `price_of` which takes two arguments: `product` and `catalogue`. If the product is available in the catalogue, the function prints its price."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "guitar costs £129.99\n"
     ]
    }
   ],
   "source": [
    "catalogue = [('guitar', 129.99), ('piano', 599.99), ('saxophone', 159.99)]\n",
    "\n",
    "# define the function price_of here\n",
    "def price_of(product, catalogue):\n",
    "    for name, price in catalogue:\n",
    "        if name is product:\n",
    "            print('{} costs £{}'.format(name, price))\n",
    "            return price\n",
    "\n",
    "price_of('guitar', catalogue)\n",
    "price_of('drum', catalogue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## return\n",
    "\n",
    "In the previous functions, the output was simply printed to the terminal. What if we want to collect the output of a function and store it in a variable. Imagine we want to calculate a discount on a price. We could write the simple function below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def calculate_disounted_price(price, percentage):\n",
    "    discount = price * percentage / 100\n",
    "    discounted_price = price - discount\n",
    "    return discounted_price\n",
    "\n",
    "bill = calculate_disounted_price(price=100, percentage=10)\n",
    "bill"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Don't forget the `return` keyword! Otherwise, the function won't return anything."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Docstrings\n",
    "\n",
    "There is an additional form of comments in Python beside the one-line `#` comments. These are docstrings. They are used to document functions, classes, modules, etc.\n",
    "\n",
    "Include docstrings in your functions! They are used to generate online documentation but also to access the `help`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_disounted_price(price, percentage):\n",
    "    '''\n",
    "    Computes the price after a discount is applied.\n",
    "    Note that the discount is in percentage: 0 means no discount, 100 means free.\n",
    "    '''\n",
    "    discount = price * percentage / 100\n",
    "    discounted_price = price - discount\n",
    "    return discounted_price\n",
    "\n",
    "help(calculate_disounted_price)"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}