06_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "This notebook is based on materials kindly provided by the [IN1900]( https://www.uio.no/studier/emner/matnat/ifi/IN1900/h19/) team.\n",
    "\n",
    "We have seen how we can use loops to avoid repeating code. This helps us obey the **DRY principle**.\n",
    "(Question: what is the DRY principle?)\n",
    "Functions are another way to reuse code.\n",
    "\n",
    "A function is a short block of code/program statements. These statements are executed when we call the function. This way, we can perform a common operation many times without having to rewrite the code each time.\n",
    "\n",
    "\n",
    "\n",
    "We define a new function with the statement `def`. `def` is followed by the function name, and a set of parentheses. If the function has parameters, we list those inside the parentheses. The function **body** follows on the next lines, and must be **indented**.\n",
    "The function ends when there are more no more indented lines, or by the `return` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This line does not belong to the function \n",
    "def function_name(parameter):\n",
    "    # This line is part of the function (has indent)\n",
    "    # ...\n",
    "    return output_value\n",
    "\n",
    "# This line does not belong to the function (no indent)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining functions\n",
    "Let's define a function for calculating the mean value of two numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean(a, b):\n",
    "    result = (a + b) / 2\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Calls\n",
    "\n",
    "Using a function is also known as *calling* a function. We have called several functions, for example `print()`.\n",
    "\n",
    "We can call our `mean` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean(5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:green\"> Exercise: Make a Function </span>\n",
    "\n",
    "Define a greeting function. It should take a name as input, and print a greeting.\n",
    "Then use the function to greet first Alice, and then Bob. The output should be:\n",
    "\t\n",
    "    Hello Alice\n",
    "    Hello Bob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(name):\n",
    "    #Your solution here\n",
    "    \n",
    "greet('Alice')\n",
    "greet('Bob')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Returning Values\n",
    "\n",
    "Our `mean` function only prints the result without storing it.\n",
    "If we want to use the result in our program, we must store it.\n",
    "We can do this by passing the results back to where the function was called, with the `return` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean(a, b):\n",
    "    result = (a + b) / 2\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can store the return value like below. (Is this a good variable name? Why/why not?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "output = mean(5,4)\n",
    "print(returned_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  `return` ends the function\n",
    "\n",
    "When we have calculated a result, we can send it to the caller with `return`. \n",
    "When Python executes the `return`-statement, the function is terminated immediately.\n",
    "In the example below, the line below the `return`-statement will never be executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean(a, b):\n",
    "    result = (a + b) / 2\n",
    "    return result\n",
    "    print(result)\n",
    "\n",
    "output = mean(5,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:green\"> Exercise: Returning Values </span>\n",
    "\n",
    "Define a function, `get_last(sequence)`, that returns the last element of a list.\n",
    "Then use the function on the list below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Your solution\n",
    "\n",
    "\n",
    "# and then print out the last item in items\n",
    "items = [\"first\", \"second\", \"third\"]\n",
    "print(get_last(items))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters\n",
    "\n",
    "Most functions need some information to work with. We can pass information to functions as *parameters*.\n",
    "We define the parameter names in the `def`-statement. Inside the function, we can use these parameter names. When the function finishes, these parameters/local variables are removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def subtract(a, b):\n",
    "    return a - b\n",
    "\n",
    "print(subtract(10, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the variable names in the function call are not the same as the variable names in the function definition. What counts is the order of the parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spam = 10\n",
    "eggs = 5\n",
    "print(subtract(spam, eggs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 5\n",
    "print(subtract(b, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters with Default Values\n",
    "\n",
    "If a parameter often has a certain value, we can set that value as the default.\n",
    "\n",
    "For instance, we can write a function to issue a fine. Most fines are for NOK 750, so we set that as the default amount:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def issue_fine(amount = 750):\n",
    "    #here we need to do something\n",
    "    print(\"Fine sent for NOK\", amount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:green\">Case Law Exercise: Functions to get Information </span>\n",
    "\n",
    "Here, we will continue working with our JSON data.\n",
    "Define a function that takes a case as an argument, and returns the name of the court.\n",
    "\n",
    "The code below applies this function to the cases in a loop. Make sure you use the function name that is called in the loop.\n",
    "We use a slightly different URL this time, to make sure we get three different courts.\n",
    "\n",
    "You might need to browse the [data](https://api.case.law/v1/cases/?jurisdiction=ill&full_case=true&decision_date_min=2011-01-01&page_size=1\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import json\n",
    "\n",
    "def #your code here\n",
    "\n",
    "URL = \"https://api.case.law/v1/cases/?full_case=true&decision_date_min=2011-01-01&page_size=3\"\n",
    "data = requests.get(URL).json()\n",
    "\n",
    "cases = data[\"results\"]\n",
    "for case in cases:\n",
    "    print(get_court_name(case))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:green\">Library Data Exercise: Function to get the Title </span>\n",
    "\n",
    "Here, we will continue working with our JSON data.\n",
    "Define a function that takes a book as an argument and returns the book title.\n",
    "\n",
    "The code below applies this function to the books in a loop. Make sure you use the function name that is called in the loop.\n",
    "\n",
    "You might need to browse the [data](https://api.nb.no/catalog/v1/items?digitalAccessibleOnly=true&size=3&filter=mediatype:bøker&q=Bing,Jon)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import json\n",
    "\n",
    "def #your code here\n",
    "\n",
    "\n",
    "URL = \"https://api.nb.no/catalog/v1/items?digitalAccessibleOnly=true&size=3&filter=mediatype:bøker&q=Bing,Jon\"\n",
    "data = requests.get(URL).json()\n",
    "embedded = data['_embedded']\n",
    "items = embedded['items']\n",
    "\n",
    "for item in items:\n",
    "    print(get_title(item))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  <span style=\"color:blue\">Key Points</span>\n",
    "\n",
    "- We should make functions to avoid repeating ourselves\n",
    "- Functions help us make modular programs\n",
    "- Functions have parameters\n",
    "- Use the `return`-statement for sending information back to the caller"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}